class Command: OPT_LANG = u'Specifies the target language (js, java, pnuts, actionscript)' OPT_OUTPUT = u'Specifies the output where the files will be generated (stdout, file or folder)' OPT_VERBOSE = u'Verbose parsing output (useful for debugging)' OPT_API = u'Generates SDoc API documentation (given the API filename)' OPT_TEST = u'Tells wether the source code is valid or not' OPT_DEFINE = u'Defines a specific target (for @specific)' OPT_OPTIONS = u'Options for program transformation passes' OPT_RUN = u'Directly runs the script (default)' OPT_COMPILE = u'Compiles the given code to the output (current) directory' OPT_RUNTIME = u'Outputs the runtime as well when compiled' OPT_VERSION = u'Ensures that Sugar is at least of the given version' OPT_SOURCE = u'Directly gives the source' OPT_INCLUDE_SOURCE = u'Includes source in compiled code' OPT_CACHE = u'Uses compilation cache' OPT_MODULE = u'Specifies the module name' OPT_LIB = u'Specifies a file to be used as a library or a library directory' OPT_INCLUDES = u'Specifies a file to be included in the copmilation output' OPT_PREPROC = u'Applies the given preprocessor to the source' OPT_IGNORES = u'Does not try to resolve the given modules' OPT_PASSES = u'Specifies the passes used in the compilation process. Passes are identified by the class name which is expected to be found in either lambdafactory.passes or lambdafactory.resolution modules, or is given as an absolute class name.' def __init__ (self, programName=None): self.programName = None self.environment = None if programName is None: programName = u'lambdafactory' self.programName = programName self.createEnvironment() self.environment.loadLanguages() self.setupEnvironment() def runAsString(self, args): """ Runs Sugar, but instead of printing the result to the given output, it returns a Python string with the result. It is very useful when embedding LambdaFactory somewhere.""" output=BytesIO() self.run(args, output) return output.getvalue().decode(u'utf-8') def run(self, arguments, output=None): if output is None: output = sys.stdout if (type(arguments) != list): arguments = list(arguments) status=0 option_parser=optparse.OptionParser() options=[] args=[] option_parser.add_option("-r", "--run", action="store_true", dest="run", default=True, help=self.OPT_RUN) option_parser.add_option("-c", "--compile", action="store_true", dest="compile", help=self.OPT_COMPILE) option_parser.add_option("-R", "--runtime", action="store_true", dest="runtime", help=self.OPT_RUNTIME) option_parser.add_option("-l", "--lang", action="store", dest="lang", help=self.OPT_LANG) option_parser.add_option("-o", "--output", action="store", dest="output", help=self.OPT_OUTPUT) option_parser.add_option("-C", "--cache", action="store", dest="cache", default=True, help=self.OPT_CACHE) option_parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help=self.OPT_VERBOSE) option_parser.add_option("-m", "--module", action="store", dest="module", help=self.OPT_MODULE) option_parser.add_option("-a", "--api", action="store", dest="api", help=self.OPT_API) option_parser.add_option("-p", "--preprocess", action="append", dest="preprocess", help=self.OPT_PREPROC) option_parser.add_option("-t", "--test", action="store_true", dest="test", help=self.OPT_TEST) option_parser.add_option("-s", "--source", action="store", dest="source", help=self.OPT_SOURCE) option_parser.add_option("-S", "--include-source", action="store_true", dest="includeSource", help=self.OPT_INCLUDE_SOURCE) option_parser.add_option("-D", "--define", action="append", dest="targets", help=self.OPT_DEFINE) option_parser.add_option("-O", "--options", action="append", dest="passOptions", help=self.OPT_OPTIONS) option_parser.add_option("-L", "--lib", action="append", dest="libraries", help=self.OPT_LIB) option_parser.add_option("-I", "--include", action="append", dest="includes", help=self.OPT_INCLUDES) option_parser.add_option("--ignores", action="append", dest="ignores", help=self.OPT_IGNORES) option_parser.add_option("-P", "--passes", action="store", dest="passes", help=self.OPT_PASSES) option_parser.add_option("-V", None, action="store", dest="version", help=self.OPT_VERSION) options, args = option_parser.parse_args(args=arguments) language=options.lang program=self.environment.program if (options.cache in [u'no', u'none', u'false', u'/dev/null', False]): self.environment.useCache = False elif (options.cache in [u'yes', u'true', True]): self.environment.useCache = True elif True: self.environment.useCache = True self.environment.cache.setPath(options.cache) if os.environ.get(u'SUGAR_MODULES'): m=os.environ[u'SUGAR_MODULES'] self.environment.options[u'modules'] = m self.environment.options[m] = True if os.environ.get(u'SUGAR_BACKEND'): self.environment.options[u'backend'] = os.environ[u'SUGAR_BACKEND'] if options.targets: for option_target in options.targets: name_value=option_target.split(u'=', 1) if (len(name_value) == 1): self.environment.options[option_target] = True elif True: self.environment.options[name_target[0]] = name_target[1] if options.api: self.environment.addPass(passes.DocumentationPass()) if options.includes: for i in options.includes: if os.path.isfile(i): parsed_module=self.parseFile(i) if parsed_module: program.addModule(parsed_module) if options.source: raise Exception(u'Not supported yet') elif True: if options.module: if (len(args) > 1): raise Exception(u'Only one source file is accepted with the -m option') for source_path in args: result_module=self.parseFile(source_path, options.module) if result_module: program.addModule(result_module) if (language == u'none'): language = None elif (not language): language = (self.environment.options.get(u'backend') or self.guessLanguage(source_path)) elif True: language = self.environment.normalizeLanguage(language) if options.libraries: for l in options.libraries: if os.path.isfile(l): module=self.parseFile(l) if (not module): return None elif True: program.addModule(module) for name_and_value in module.getSlots(): name_and_value[1].addAnnotation(self.environment.getFactory().annotation(u'shadow')) elif True: self.environment.addLibraryPath(l) if (language == u'none'): language = None if options.passes: self.setupPasses(language, options.passes.split(u','), (options.passOptions or [])) elif True: self.setupPasses(language, None, (options.passOptions or [])) if program.getModules(): self.transformProgram(program) if options.api: doc_pass=self.environment.getPass(u'Documentation') doc_pass.setWriter(self.getWriter(u'js')) json_documentation = doc_pass.asJSON() if (options.api == u'-'): output.write(json_documentation) elif True: f=open(options.api, u'wb') f.write(ensureOutput(json_documentation, f)) f.close() elif options.compile: program_source=self.writeProgram(program, language, options.runtime, options.includeSource) if (not options.output): output.write(ensureOutput(program_source, output)) output.write(ensureOutput(u'\n', output)) elif os.path.isdir(options.output): splitter=FileSplitter(options.output) splitter.fromString(program_source) elif True: f=open(options.output, u'wb') f.write(ensureOutput(program_source, f)) f.close() elif options.run: program_source=self.writeProgram(program, language, True, options.includeSource) file_and_path=tempfile.mkstemp() f=open(file_and_path[0], u'wb') f.write(ensureOutput(program_source, f)) f.close() args_str=u' '.join(args[1:]) interpreter=None path=file_and_path[1] compilers=None command=None if (language in [u'js', u'javascript', u'es', u'ecmascript']): interpreter = (os.getenv(u'SUGAR_JS') or u'js') command = ((((interpreter + u' ') + path) + u' ') + args_str) elif (language in [u'python']): interpreter = (os.getenv(u'SUGAR_PYTHON') or u'python') command = ((((interpreter + u' ') + path) + u' ') + args_str) if command: status = ((os.system(command) / 256) or status) elif True: self.environment.report.error(u'No command defined to run language: {0}'.format(language)) os.unlink(path) return program def parseFile(self, sourcePath, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseFile(sourcePath, moduleName) def parseString(self, text, extension, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseString(text, extension, moduleName) def transformProgram(self, program): self.environment.runPasses(program) def guessLanguage(self, sourcePath): for name_and_value in self.environment.languages.items(): if name_and_value[1].recognizes(sourcePath): return name_and_value[0] return None def getWriter(self, language): if (not language): return None name=language language = self.environment.loadLanguage(language) if (language and language.writer): writer=language.writer() writer.report = self.environment.report writer.setEnvironment(self.environment) return writer elif True: self.environment.report.error(u'Language not defined: {0}'.format(name)) return None def writeProgram(self, program, inLanguage, includeRuntime=None, includeSource=None): if includeRuntime is None: includeRuntime = False if includeSource is None: includeSource = False writer=self.getWriter(inLanguage) if writer: program_source=writer.run(program) return program_source elif True: return u'' def createEnvironment(self): self.environment = Environment() def setupEnvironment(self): pass def setupPasses(self, language=None, withPasses=None, options=None): if language is None: language = None if withPasses is None: withPasses = None if options is None: options = None o={} for _ in options: k_v=_.split(u'=') if (len(k_v) == 1): o[k_v[0]] = True elif True: o[k_v[0]] = k_v[1] options = o if (not withPasses): self.environment.addPass(passes.Importation(), options) self.environment.addPass(passes.ControlFlow(), options) self.environment.addPass(resolution.BasicDataFlow(), options) self.environment.addPass(resolution.DataFlowBinding(), options) elif True: for the_pass in withPasses: if (the_pass == u'std'): self.environment.addPass(passes.Importation(), options) self.environment.addPass(passes.ControlFlow(), options) self.environment.addPass(resolution.BasicDataFlow(), options) self.environment.addPass(resolution.DataFlowBinding(), options) elif (the_pass.find(u'.') == -1): pass_class=None if hasattr(passes, the_pass): pass_class = getattr(passes, the_pass) elif hasattr(resolution, the_pass): pass_class = getattr(resolution, the_pass) elif True: self.environment.report.error(u'LambdaFactory standard pass not found:', the_pass) assert(None) self.environment.addPass(pass_class(), options) elif True: module_name=the_pass[0:the_pass.rfind(u'.')] exec((u'import ' + module_name)) pass_class=eval(the_pass) if pass_class: self.environment.addPass(pass_class(), options) elif True: self.environment.report.error(u'Custom pass not found:', the_pass) assert(None)
def createEnvironment(self): self.environment = Environment()
class Command: OPT_LANG = 'Specifies the target language (js, java, pnuts, actionscript)' OPT_OUTPUT = 'Specifies the output where the files will be generated (stdout, file or folder)' OPT_VERBOSE = 'Verbose parsing output (useful for debugging)' OPT_API = 'Generates SDoc API documentation (given the API filename)' OPT_TEST = 'Tells wether the source code is valid or not' OPT_DEFINE = 'Defines a specific target (for @specific)' OPT_OPTIONS = 'Options for program transformation passes' OPT_RUN = 'Directly runs the script (default)' OPT_COMPILE = 'Compiles the given code to the output (current) directory' OPT_RUNTIME = 'Outputs the runtime as well when compiled' OPT_VERSION = 'Ensures that Sugar is at least of the given version' OPT_SOURCE = 'Directly gives the source' OPT_INCLUDE_SOURCE = 'Includes source in compiled code' OPT_CACHE = 'Uses compilation cache' OPT_MODULE = 'Specifies the module name' OPT_LIB = 'Specifies a file to be used as a library or a library directory' OPT_INCLUDES = 'Specifies a file to be included in the copmilation output' OPT_PREPROC = 'Applies the given preprocessor to the source' OPT_PASSES = 'Specifies the passes used in the compilation process. Passes are identified by the class name which is expected to be found in either lambdafactory.passes or lambdafactory.resolution modules, or is given as an absolute class name.' def __init__ (self, programName=None): self.programName = None self.environment = None if programName is None: programName = 'lambdafactory' self.programName = programName self.createEnvironment() self.environment.loadLanguages() self.setupEnvironment() def runAsString(self, args): """Runs Sugar, but instead of printing the result to the given output, it returns a Python string with the result. It is very useful when embedding LambdaFactory somewhere.""" output=StringIO() self.run(args, output) return ('' + output.getvalue()) def run(self, arguments, output=None): if output is None: output = sys.stdout if (type(arguments) != list): arguments = list(arguments) status=0 option_parser=optparse.OptionParser() options=[] args=[] option_parser.add_option("-r", "--run", action="store_true", dest="run", default=True, help=self.OPT_RUN) option_parser.add_option("-c", "--compile", action="store_true", dest="compile", help=self.OPT_COMPILE) option_parser.add_option("-R", "--runtime", action="store_true", dest="runtime", help=self.OPT_RUNTIME) option_parser.add_option("-l", "--lang", action="store", dest="lang", help=self.OPT_LANG) option_parser.add_option("-o", "--output", action="store", dest="output", help=self.OPT_OUTPUT) option_parser.add_option("-C", "--cache", action="store_true", dest="cache", default=False, help=self.OPT_CACHE) option_parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help=self.OPT_VERBOSE) option_parser.add_option("-m", "--module", action="store", dest="module", help=self.OPT_MODULE) option_parser.add_option("-a", "--api", action="store", dest="api", help=self.OPT_API) option_parser.add_option("-p", "--preprocess", action="append", dest="preprocess", help=self.OPT_PREPROC) option_parser.add_option("-t", "--test", action="store_true", dest="test", help=self.OPT_TEST) option_parser.add_option("-s", "--source", action="store", dest="source", help=self.OPT_SOURCE) option_parser.add_option("-S", "--include-source", action="store_true", dest="includeSource", help=self.OPT_INCLUDE_SOURCE) option_parser.add_option("-D", "--define", action="append", dest="targets", help=self.OPT_DEFINE) option_parser.add_option("-O", "--options", action="append", dest="passOptions", help=self.OPT_OPTIONS) option_parser.add_option("-L", "--lib", action="append", dest="libraries", help=self.OPT_LIB) option_parser.add_option("-I", "--include", action="append", dest="includes", help=self.OPT_INCLUDES) option_parser.add_option("-P", "--passes", action="store", dest="passes", help=self.OPT_PASSES) option_parser.add_option("-V", None, action="store", dest="version", help=self.OPT_VERSION) options, args = option_parser.parse_args(args=arguments) language=options.lang program=self.environment.program self.environment.useCache = options.cache if options.targets: for option_target in options.targets: self.environment.options[option_target] = True if options.api: self.environment.addPass(passes.DocumentationPass()) if options.includes: for i in options.includes: if os.path.isfile(i): parsed_module=self.parseFile(i) if parsed_module: program.addModule(parsed_module) if options.source: throw.Exception('Not supported yet') elif True: if options.module: if (len(args) > 1): throw.Exception('Only one source file is accepted with the -m option') for source_path in args: result_module=self.parseFile(source_path, options.module) if result_module: program.addModule(result_module) if (not language): language = self.guessLanguage(source_path) elif True: language = self.environment.normalizeLanguage(language) if options.libraries: for l in options.libraries: if os.path.isfile(l): module=self.parseFile(l) program.addModule(module) for name_and_value in module.getSlots(): name_and_value[1].addAnnotation(self.environment.getFactory().annotation('shadow')) elif True: self.environment.addLibraryPath(l) if (not language): raise ERR_NO_LANGUAGE_SPECIFIED if options.passes: self.setupPasses(language, options.passes.split(','), (options.passOptions or [])) elif True: self.setupPasses(language, None, (options.passOptions or [])) if program.getModules(): self.transformProgram(program) if options.api: doc_pass=self.environment.getPass('Documentation') doc_pass.setWriter(self.getWriter('js')) json_documentation = doc_pass.asJSON() if (options.api == '-'): output.write(json_documentation) elif True: f=file(options.api, mode=('w')) f.write(json_documentation) f.close() elif options.compile: program_source=self.writeProgram(program, language, options.runtime, options.includeSource) if (not options.output): output.write((program_source + '\n')) elif os.path.isdir(options.output): splitter=FileSplitter(options.output) splitter.fromString(program_source) elif True: f=file(options.output, mode=('a')) f.write(program_source) elif options.run: program_source=self.writeProgram(program, language, True, options.includeSource) file_and_path=tempfile.mkstemp() os.write(file_and_path[0], program_source) os.close(file_and_path[0]) args_str=' '.join(args[1:]) interpreter=None path=file_and_path[1] compilers=None if (language in ['js', 'javascript']): interpreter = (os.getenv('SUGAR_JS') or 'js') command = ((((interpreter + ' ') + path) + ' ') + args_str) elif (language in ['pnuts']): interpreter = (os.getenv('SUGAR_PNUTS') or 'pnuts') command = ((((interpreter + ' ') + path) + ' ') + args_str) elif (language in ['python']): interpreter = (os.getenv('SUGAR_PYTHON') or 'python') command = ((((interpreter + ' ') + path) + ' ') + args_str) elif True: raise ERR_NO_RUNTIME_AVAILABLE(language) status = ((os.system(command) / 256) or status) os.unlink(path) return program def parseFile(self, sourcePath, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseFile(sourcePath, moduleName) def parseString(self, text, extension, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseString(text, extension, moduleName) def transformProgram(self, program): self.environment.runPasses(program) def guessLanguage(self, sourcePath): for name_and_value in self.environment.languages.items(): if name_and_value[1].recognizes(sourcePath): return name_and_value[0] return None def getWriter(self, language): language = self.environment.loadLanguage(language) writer=language.writer() writer.report = self.environment.report writer.setEnvironment(self.environment) return writer def writeProgram(self, program, inLanguage, includeRuntime=None, includeSource=None): if includeRuntime is None: includeRuntime = False if includeSource is None: includeSource = False writer=self.getWriter(inLanguage) writer.setOption('INCLUDE_SOURCE', includeSource) program_source=writer.run(program) if includeRuntime: program_source = (writer.getRuntimeSource() + program_source) return program_source def createEnvironment(self): self.environment = Environment() def setupEnvironment(self): pass def setupPasses(self, language=None, withPasses=None, options=None): if language is None: language = None if withPasses is None: withPasses = None if options is None: options = None if (not withPasses): if (((language == 'javascript') or (language == 'actionscript')) and (not ('NORUNTIME' in options))): self.environment.addPass(passes.ExtendJSRuntime()) self.environment.addPass(passes.Importation()) self.environment.addPass(resolution.BasicDataFlow()) self.environment.addPass(resolution.DataFlowBinding()) elif True: for the_pass in withPasses: if (the_pass.find('.') == -1): pass_class=None if hasattr(passes, the_pass): pass_class=getattr(passes, the_pass) elif hasattr(resolution, the_pass): pass_class=getattr(resolution, the_pass) elif True: self.environment.report.error('LambdaFactory standard pass not found:', the_pass) assert(None) self.environment.addPass(pass_class()) elif True: module_name=the_pass[0:the_pass.rfind('.')] exec(('import ' + module_name)) pass_class=eval(the_pass) if pass_class: self.environment.addPass(pass_class()) elif True: self.environment.report.error('Custom pass not found:', the_pass) assert(None)
class Command: OPT_LANG = 'Specifies the target language (js, java, pnuts, actionscript)' OPT_OUTPUT = 'Specifies the output where the files will be generated (stdout, file or folder)' OPT_VERBOSE = 'Verbose parsing output (useful for debugging)' OPT_API = 'Generates SDoc API documentation (given the API filename)' OPT_TEST = 'Tells wether the source code is valid or not' OPT_DEFINE = 'Defines a specific target (for @specific)' OPT_OPTIONS = 'Options for program transformation passes' OPT_RUN = 'Directly runs the script (default)' OPT_COMPILE = 'Compiles the given code to the output (current) directory' OPT_RUNTIME = 'Outputs the runtime as well when compiled' OPT_VERSION = 'Ensures that Sugar is at least of the given version' OPT_SOURCE = 'Directly gives the source' OPT_MODULE = 'Specifies the module name' OPT_LIB = 'Specifies a file to be used as a library or a library directory' OPT_INCLUDES = 'Specifies a file to be included in the copmilation output' OPT_PREPROC = 'Applies the given preprocessor to the source' OPT_PASSES = 'Specifies the passes used in the compilation process. Passes are identified by the class name which is expected to be found in either lambdafactory.passes or lambdafactory.resolution modules, or is given as an absolute class name.' def __init__(self, programName=None): self.programName = None self.environment = None if programName is None: programName = 'lambdaf' self.programName = programName self.createEnvironment() self.environment.loadLanguages() self.setupEnvironment() def runAsString(self, args): """Runs Sugar, but instead of printing the result to the given output, it returns a Python string with the result. It is very useful when embedding LambdaFactory somewhere.""" output = StringIO() self.run(args, output) return ('' + output.getvalue()) def run(self, arguments, output=None): if output is None: output = sys.stdout if (type(arguments) != list): arguments = list(arguments) status = 0 option_parser = optparse.OptionParser() options = [] args = [] option_parser.add_option("-r", "--run", action="store_true", dest="run", default=True, help=self.OPT_RUN) option_parser.add_option("-c", "--compile", action="store_true", dest="compile", help=self.OPT_COMPILE) option_parser.add_option("-R", "--runtime", action="store_true", dest="runtime", help=self.OPT_RUNTIME) option_parser.add_option("-l", "--lang", action="store", dest="lang", help=self.OPT_LANG) option_parser.add_option("-o", "--output", action="store", dest="output", help=self.OPT_OUTPUT) option_parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help=self.OPT_VERBOSE) option_parser.add_option("-m", "--module", action="store", dest="module", help=self.OPT_MODULE) option_parser.add_option("-a", "--api", action="store", dest="api", help=self.OPT_API) option_parser.add_option("-p", "--preprocess", action="append", dest="preprocess", help=self.OPT_PREPROC) option_parser.add_option("-t", "--test", action="store_true", dest="test", help=self.OPT_TEST) option_parser.add_option("-s", "--source", action="store", dest="source", help=self.OPT_SOURCE) option_parser.add_option("-D", "--define", action="append", dest="targets", help=self.OPT_DEFINE) option_parser.add_option("-O", "--options", action="append", dest="passOptions", help=self.OPT_OPTIONS) option_parser.add_option("-L", "--lib", action="append", dest="libraries", help=self.OPT_LIB) option_parser.add_option("-I", "--include", action="append", dest="includes", help=self.OPT_INCLUDES) option_parser.add_option("-P", "--passes", action="store", dest="passes", help=self.OPT_PASSES) option_parser.add_option("-V", None, action="store", dest="version", help=self.OPT_VERSION) options, args = option_parser.parse_args(args=arguments) language = options.lang if options.targets: for option_target in options.targets: self.environment.options[option_target] = True if options.api: self.environment.addPass(passes.DocumentationPass()) if options.includes: for i in options.includes: if os.path.isfile(i): self.parseFile(i) if options.source: self.parseSource(args[0], options.source, options.module) elif True: if options.module: if (len(args) > 1): throw.Exception( 'Only one source file is accepted with the -m option') for source_path in args: result_module = self.parseFile(source_path, options.module) if (not language): language = self.guessLanguage(source_path) elif True: language = self.environment.normalizeLanguage(language) if options.libraries: for l in options.libraries: if os.path.isfile(l): module = self.parseFile(l) for name_and_value in module.getSlots(): name_and_value[1].addAnnotation( self.environment.getFactory().annotation('shadow')) elif True: self.environment.addLibraryPath(l) if (not language): raise ERR_NO_LANGUAGE_SPECIFIED if options.passes: self.setupPasses(language, options.passes.split(','), (options.passOptions or [])) elif True: self.setupPasses(language, None, (options.passOptions or [])) self.transformProgram() if options.api: html_documentation = self.environment.getPass( 'Documentation').asHTML() if (options.api == '-'): output.write(html_documentation) elif True: f = file(options.api, mode=('w')) f.write(html_documentation) f.close() elif options.compile: program_source = self.writeProgram(language, options.runtime) if (not options.output): output.write((program_source + '\n')) elif os.path.isdir(options.output): splitter = FileSplitter(options.output) splitter.fromString(program_source) elif True: f = file(options.output, mode=('a')) f.write(program_source) elif options.run: program_source = self.writeProgram(language, True) file_and_path = tempfile.mkstemp() os.write(file_and_path[0], program_source) os.close(file_and_path[0]) args_str = ' '.join(args[1:]) interpreter = None path = file_and_path[1] compilers = None if (language in ['js', 'javascript']): interpreter = (os.getenv('SUGAR_JS') or 'rhino') command = ((((interpreter + ' ') + path) + ' ') + args_str) elif (language in ['pnuts']): interpreter = (os.getenv('SUGAR_PNUTS') or 'pnuts') command = ((((interpreter + ' ') + path) + ' ') + args_str) elif (language in ['python']): interpreter = (os.getenv('SUGAR_PYTHON') or 'python') command = ((((interpreter + ' ') + path) + ' ') + args_str) elif True: raise ERR_NO_RUNTIME_AVAILABLE(language) status = ((os.system(command) / 256) or status) os.unlink(path) def parseFile(self, sourcePath, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseFile(sourcePath, moduleName) def parseSource(self, source, extension, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseSource(source, extension, moduleName) def transformProgram(self): self.environment.runPasses() def guessLanguage(self, sourcePath): for name_and_value in self.environment.languages.items(): if name_and_value[1].recognizes(sourcePath): return name_and_value[0] return None def setProgram(self, program): return self.environment.setProgram(program) def getProgram(self): return self.environment.getProgram() def writeProgram(self, inLanguage, includeRuntime=None): if includeRuntime is None: includeRuntime = False language = self.environment.loadLanguage(inLanguage) writer = language.writer() writer.report = self.environment.report writer.setEnvironment(self.environment) program_source = writer.run() if includeRuntime: program_source = (writer.getRuntimeSource() + program_source) return program_source def createEnvironment(self): self.environment = Environment() def setupEnvironment(self): pass def setupPasses(self, language=None, withPasses=None, options=None): if language is None: language = None if withPasses is None: withPasses = None if options is None: options = None if (not withPasses): if (((language == 'javascript') or (language == 'actionscript')) and (not ('NORUNTIME' in options))): self.environment.addPass(passes.ExtendJSRuntime()) self.environment.addPass(passes.Importation()) self.environment.addPass(resolution.BasicDataFlow()) self.environment.addPass(resolution.DataFlowBinding()) elif True: for the_pass in withPasses: if (the_pass.find('.') == -1): pass_class = None if hasattr(passes, the_pass): pass_class = getattr(passes, the_pass) elif hasattr(resolution, the_pass): pass_class = getattr(resolution, the_pass) elif True: self.environment.report.error( 'LambdaFactory standard pass not found:', the_pass) assert (None) self.environment.addPass(pass_class()) elif True: module_name = the_pass[0:the_pass.rfind('.')] exec(('import ' + module_name)) pass_class = eval(the_pass) if pass_class: self.environment.addPass(pass_class()) elif True: self.environment.report.error('Custom pass not found:', the_pass) assert (None)
class Command: OPT_LANG = "Specifies the target language (js, java, pnuts, actionscript)" OPT_OUTPUT = "Specifies the output where the files will be generated (stdout, file or folder)" OPT_VERBOSE = "Verbose parsing output (useful for debugging)" OPT_API = "Generates SDoc API documentation (given the API filename)" OPT_TEST = "Tells wether the source code is valid or not" OPT_DEFINE = "Defines a specific target (for @specific)" OPT_OPTIONS = "Options for program transformation passes" OPT_RUN = "Directly runs the script (default)" OPT_COMPILE = "Compiles the given code to the output (current) directory" OPT_RUNTIME = "Outputs the runtime as well when compiled" OPT_VERSION = "Ensures that Sugar is at least of the given version" OPT_SOURCE = "Directly gives the source" OPT_MODULE = "Specifies the module name" OPT_LIB = "Specifies a file to be used as a library or a library directory" OPT_INCLUDES = "Specifies a file to be included in the copmilation output" OPT_PREPROC = "Applies the given preprocessor to the source" OPT_PASSES = "Specifies the passes used in the compilation process. Passes are identified by the class name which is expected to be found in either lambdafactory.passes or lambdafactory.resolution modules, or is given as an absolute class name." def __init__(self, programName=None): self.programName = None self.environment = None if programName is None: programName = "lambdaf" self.programName = programName self.createEnvironment() self.environment.loadLanguages() self.setupEnvironment() def runAsString(self, args): """Runs Sugar, but instead of printing the result to the given output, it returns a Python string with the result. It is very useful when embedding LambdaFactory somewhere.""" output = StringIO() self.run(args, output) return "" + output.getvalue() def run(self, arguments, output=None): if output is None: output = sys.stdout if type(arguments) != list: arguments = list(arguments) status = 0 option_parser = optparse.OptionParser() options = [] args = [] option_parser.add_option("-r", "--run", action="store_true", dest="run", default=True, help=self.OPT_RUN) option_parser.add_option("-c", "--compile", action="store_true", dest="compile", help=self.OPT_COMPILE) option_parser.add_option("-R", "--runtime", action="store_true", dest="runtime", help=self.OPT_RUNTIME) option_parser.add_option("-l", "--lang", action="store", dest="lang", help=self.OPT_LANG) option_parser.add_option("-o", "--output", action="store", dest="output", help=self.OPT_OUTPUT) option_parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help=self.OPT_VERBOSE) option_parser.add_option("-m", "--module", action="store", dest="module", help=self.OPT_MODULE) option_parser.add_option("-a", "--api", action="store", dest="api", help=self.OPT_API) option_parser.add_option("-p", "--preprocess", action="append", dest="preprocess", help=self.OPT_PREPROC) option_parser.add_option("-t", "--test", action="store_true", dest="test", help=self.OPT_TEST) option_parser.add_option("-s", "--source", action="store", dest="source", help=self.OPT_SOURCE) option_parser.add_option("-D", "--define", action="append", dest="targets", help=self.OPT_DEFINE) option_parser.add_option("-O", "--options", action="append", dest="passOptions", help=self.OPT_OPTIONS) option_parser.add_option("-L", "--lib", action="append", dest="libraries", help=self.OPT_LIB) option_parser.add_option("-I", "--include", action="append", dest="includes", help=self.OPT_INCLUDES) option_parser.add_option("-P", "--passes", action="store", dest="passes", help=self.OPT_PASSES) option_parser.add_option("-V", None, action="store", dest="version", help=self.OPT_VERSION) options, args = option_parser.parse_args(args=arguments) language = options.lang if options.targets: for option_target in options.targets: self.environment.options[option_target] = True if options.api: self.environment.addPass(passes.DocumentationPass()) if options.includes: for i in options.includes: if os.path.isfile(i): self.parseFile(i) if options.source: self.parseSource(args[0], options.source, options.module) elif True: if options.module: if len(args) > 1: throw.Exception("Only one source file is accepted with the -m option") for source_path in args: result_module = self.parseFile(source_path, options.module) if not language: language = self.guessLanguage(source_path) elif True: language = self.environment.normalizeLanguage(language) if options.libraries: for l in options.libraries: if os.path.isfile(l): module = self.parseFile(l) for name_and_value in module.getSlots(): name_and_value[1].addAnnotation(self.environment.getFactory().annotation("shadow")) elif True: self.environment.addLibraryPath(l) if not language: raise ERR_NO_LANGUAGE_SPECIFIED if options.passes: self.setupPasses(language, options.passes.split(","), (options.passOptions or [])) elif True: self.setupPasses(language, None, (options.passOptions or [])) self.transformProgram() if options.api: html_documentation = self.environment.getPass("Documentation").asHTML() if options.api == "-": output.write(html_documentation) elif True: f = file(options.api, mode=("w")) f.write(html_documentation) f.close() elif options.compile: program_source = self.writeProgram(language, options.runtime) if not options.output: output.write((program_source + "\n")) elif os.path.isdir(options.output): splitter = FileSplitter(options.output) splitter.fromString(program_source) elif True: f = file(options.output, mode=("a")) f.write(program_source) elif options.run: program_source = self.writeProgram(language, True) file_and_path = tempfile.mkstemp() os.write(file_and_path[0], program_source) os.close(file_and_path[0]) args_str = " ".join(args[1:]) interpreter = None path = file_and_path[1] compilers = None if language in ["js", "javascript"]: interpreter = os.getenv("SUGAR_JS") or "rhino" command = (((interpreter + " ") + path) + " ") + args_str elif language in ["pnuts"]: interpreter = os.getenv("SUGAR_PNUTS") or "pnuts" command = (((interpreter + " ") + path) + " ") + args_str elif language in ["python"]: interpreter = os.getenv("SUGAR_PYTHON") or "python" command = (((interpreter + " ") + path) + " ") + args_str elif True: raise ERR_NO_RUNTIME_AVAILABLE(language) status = (os.system(command) / 256) or status os.unlink(path) def parseFile(self, sourcePath, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseFile(sourcePath, moduleName) def parseSource(self, source, extension, moduleName=None): if moduleName is None: moduleName = None return self.environment.parseSource(source, extension, moduleName) def transformProgram(self): self.environment.runPasses() def guessLanguage(self, sourcePath): for name_and_value in self.environment.languages.items(): if name_and_value[1].recognizes(sourcePath): return name_and_value[0] return None def setProgram(self, program): return self.environment.setProgram(program) def getProgram(self): return self.environment.getProgram() def writeProgram(self, inLanguage, includeRuntime=None): if includeRuntime is None: includeRuntime = False language = self.environment.loadLanguage(inLanguage) writer = language.writer() writer.report = self.environment.report writer.setEnvironment(self.environment) program_source = writer.run() if includeRuntime: program_source = writer.getRuntimeSource() + program_source return program_source def createEnvironment(self): self.environment = Environment() def setupEnvironment(self): pass def setupPasses(self, language=None, withPasses=None, options=None): if language is None: language = None if withPasses is None: withPasses = None if options is None: options = None if not withPasses: if ((language == "javascript") or (language == "actionscript")) and (not ("NORUNTIME" in options)): self.environment.addPass(passes.ExtendJSRuntime()) self.environment.addPass(passes.Importation()) self.environment.addPass(resolution.BasicDataFlow()) self.environment.addPass(resolution.DataFlowBinding()) elif True: for the_pass in withPasses: if the_pass.find(".") == -1: pass_class = None if hasattr(passes, the_pass): pass_class = getattr(passes, the_pass) elif hasattr(resolution, the_pass): pass_class = getattr(resolution, the_pass) elif True: self.environment.report.error("LambdaFactory standard pass not found:", the_pass) assert None self.environment.addPass(pass_class()) elif True: module_name = the_pass[0 : the_pass.rfind(".")] exec(("import " + module_name)) pass_class = eval(the_pass) if pass_class: self.environment.addPass(pass_class()) elif True: self.environment.report.error("Custom pass not found:", the_pass) assert None