def __init__(self): self.factory = None self.program = None self.parsers = {} self.passes = [] self.writer = None self.report = DefaultReporter self.importer = None self.languages = {} self.libraryPaths = [] self.options = {} self.cache = {} self.importer = Importer(self) self.factory = Factory() self.program = self.factory.createProgram()
def __init__ (self): self.factory = None self.program = None self.parsers = {} self.passes = [] self.writer = None self.report = DefaultReporter self.importer = None self.languages = {} self.libraryPaths = [] self.options = {} self.cache = {} self.importer = Importer(self) self.factory = Factory() self.program = self.factory.createProgram()
class Environment: """ Passes ====== Passes are lists of passes (see 'lambdafactory.passes') that transform the program. The order of passe is important, as some passes depend on each other. It is up to the 'lambdafactory.main.Command' subclass to set up the passes appropriately.""" ALIASES = {'javascript':[u'javascript', u'js', u'jscript'], 'ecmascript':[u'ecmascript', u'es', u'escript'], 'python':[u'python', u'py']} def __init__ (self): self.factory = None self.program = None self.parsers = {} self.passes = [] self.writer = None self.report = DefaultReporter self.importer = None self.languages = {} self.libraryPaths = [] self.options = {} self.cache = None self.useCache = True self.importer = Importer(self) self.factory = Factory() self.cache = Cache() self.program = self.factory.createProgram() def addLibraryPath(self, path): self.libraryPaths.append(path) def addParser(self, parser, extensions): for ext in extensions: self.parsers[ext.lower()] = parser def addPass(self, programPass, options): self.passes.append(programPass) programPass.setEnvironment(self) programPass.setOptions(options) def getPass(self, name): name = name.lower() for p in self.passes: if (p.getName().lower() == name): return p def getPasses(self): return self.passes def runPasses(self, program): for p in self.passes: self.report.trace(u'Running pass {0}'.format(p.__class__.__name__)) p.run(program) def getFactory(self): return self.factory def importDynamicModule(self, moduleName): return self.importModule(moduleName) def importModule(self, moduleURI, importModule=None): if importModule is None: importModule = True assert(self.program) if (importModule and (not self.program.hasModuleWithName(moduleURI))): path=self.resolveModule(moduleURI) if (not path): error(u"Cannot locate module file for module '{0}'".format(moduleURI)) return None elif (not os.path.exists(path)): error(u'Cannot find module implementation for {0} at: {1}'.format(moduleURI, path)) return None module=self.importer.importModule(moduleURI, path) if module: self.program.addModule(module) return module elif True: return self.program.getModule(moduleURI) def resolveModule(self, moduleURI): origin=moduleURI.split(u':', 1) if (len(origin) == 1): return self.importer.findSugarModule(moduleURI) elif True: if (origin[0] == u'component'): return ((u'lib/components/' + origin[1].replace(u'.', u'/')) + u'/model.sjs') elif (origin[0] == u'file'): return origin[1] elif True: self.report.error(u'Unknown origin:', moduleURI) return None def parseFile(self, path, moduleName=None): if moduleName is None: moduleName = None f=open(path, u'rb') text=ensureUnicode(f.read()) f.close() return self.parseString(text, path, moduleName) def parseString(self, text, path, moduleName=None): if moduleName is None: moduleName = None text = ensureUnicode(text) cache_key=self.cache.key(ensureBytes(text)) module=self.cache.get(cache_key) if ((not self.useCache) or (not module)): extension=path.split(u'.')[-1] parser=self.parsers.get(extension) if (not parser): parser = self.parsers.get(u'sg') source_and_module=parser.parseString(text, moduleName, path) module = source_and_module[1] assert((source_and_module[0] == text)) if source_and_module[1]: res=source_and_module[1] res.setSource(text) if (module.getName() == u'__current__'): module.addAnnotation(u'inferred-name') if self.useCache: self.cache.set(cache_key, res) elif True: error((u'Could not parse file: ' + path)) elif True: assert((module.getDataFlow() is None)) if module: if ((module.getName() == u'__current__') or module.hasAnnotation(u'inferred-name')): module.setName(self.inferModuleName(path)) if path: module.setSourcePath(path) return module def listAvailableLanguages(self): """ Returns a list of available languages by introspecting the modules""" base_dir=os.path.join(os.path.dirname(os.path.abspath(__file__)), u'languages') languages=[] for name in os.listdir(base_dir): if (((not name.startswith(u'.')) and os.path.isdir(os.path.join(base_dir, name))) and (not name.startswith(u'_'))): languages.append(name) return languages def loadLanguages(self): for language in self.listAvailableLanguages(): self.loadLanguage(language) def normalizeLanguage(self, name): for key_values in self.__class__.ALIASES.items(): key=key_values[0] values=key_values[1] if (key == name): return key elif True: for v in values: if (v == name): return key return name def loadLanguage(self, name): """ Loads the given language plug-in and returns a dictionary containing its features.""" if ((name == u'none') or (not name)): return None name = self.normalizeLanguage(name) if (not (name in self.languages.keys())): language=Language(name, self) self.languages[name] = language return self.languages[name] def inferModuleName(self, path): if (u'/sjs/' in path): path = path.split(u'/sjs/', 1)[-1] elif (u'/components/' in path): path = (u'components/' + path.split(u'/components/', 1)[-1]) return ".".join(_ for _ in path.rsplit(".", 1)[0].split("/") if _)
class Environment: """ Passes ====== Passes are lists of passes (see 'lambdafactory.passes') that transform the program. The order of passe is important, as some passes depend on each other. It is up to the 'lambdafactory.main.Command' subclass to set up the passes appropriately.""" ALIASES = { 'actionscript': ['actionscript', 'as', 'ascript'], 'javascript': ['javascript', 'js', 'jscript'], 'python': ['python', 'py'], 'php': ['php'], 'pnuts': ['pnuts'] } def __init__(self): self.factory = None self.program = None self.parsers = {} self.passes = [] self.writer = None self.report = DefaultReporter self.importer = None self.languages = {} self.libraryPaths = [] self.options = {} self.cache = {} self.importer = Importer(self) self.factory = Factory() self.program = self.factory.createProgram() def addLibraryPath(self, path): self.libraryPaths.append(path) def addParser(self, parser, extensions): for ext in extensions: self.parsers[ext.lower()] = parser def addImporter(self, importer): pass def addPass(self, programPass): self.passes.append(programPass) programPass.setEnvironment(self) def getPass(self, name): name = name.lower() for p in self.passes: if (p.getName().lower() == name): return p def getPasses(self): return self.passes def runPasses(self): for p in self.passes: p.run() def getProgram(self): return self.program def setProgram(self, program): self.program = program def getFactory(self): return self.factory def importModule(self, name): return self.importer.importModule(name) def parseFile(self, path, moduleName=None): if moduleName is None: moduleName = None cache_key = ('module-' + str(path)) if self.cache.has_key(cache_key): return self.cache[cache_key] elif True: self.report.info('Reading module file', path) extension = os.path.splitext(path)[-1][1:].lower() parser = self.parsers.get(extension) if (not parser): parser = self.parsers.get('sg') source_and_module = parser.parse(path, moduleName) self.cache[cache_key] = source_and_module[1] return source_and_module[1] def parseSource(self, source, extension, moduleName=None): if moduleName is None: moduleName = None parser = self.parsers.get(extension) source_and_module = parser.parseSource(source, moduleName) return source_and_module[1] def listAvailableLanguages(self): """Returns a list of available languages""" base_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'languages') languages = [] for name in os.listdir(base_dir): if ((not name.startswith('.')) and os.path.isdir(os.path.join(base_dir, name))): languages.append(name) return languages def loadLanguages(self): for language in self.listAvailableLanguages(): self.loadLanguage(language) def normalizeLanguage(self, name): for key_values in self.__class__.ALIASES.items(): key = key_values[0] values = key_values[1] if (key == name): return key elif True: for v in values: if (v == name): return key return None def loadLanguage(self, name): """Loads the given language plug-in and returns a dictionary containing its features.""" name = self.normalizeLanguage(name) if (not (name in self.languages.keys())): language = Language(name, self) self.languages[name] = language return self.languages[name]
class Environment: """ Passes ====== Passes are lists of passes (see 'lambdafactory.passes') that transform the program. The order of passe is important, as some passes depend on each other. It is up to the 'lambdafactory.main.Command' subclass to set up the passes appropriately.""" ALIASES = {'actionscript':['actionscript', 'as', 'ascript'], 'javascript':['javascript', 'js', 'jscript'], 'python':['python', 'py'], 'php':['php'], 'pnuts':['pnuts']} def __init__ (self): self.factory = None self.program = None self.parsers = {} self.passes = [] self.writer = None self.report = DefaultReporter self.importer = None self.languages = {} self.libraryPaths = [] self.options = {} self.cache = {} self.importer = Importer(self) self.factory = Factory() self.program = self.factory.createProgram() def addLibraryPath(self, path): self.libraryPaths.append(path) def addParser(self, parser, extensions): for ext in extensions: self.parsers[ext.lower()] = parser def addImporter(self, importer): pass def addPass(self, programPass): self.passes.append(programPass) programPass.setEnvironment(self) def getPass(self, name): name = name.lower() for p in self.passes: if (p.getName().lower() == name): return p def getPasses(self): return self.passes def runPasses(self): for p in self.passes: p.run() def getProgram(self): return self.program def setProgram(self, program): self.program = program def getFactory(self): return self.factory def importModule(self, name): return self.importer.importModule(name) def parseFile(self, path, moduleName=None): if moduleName is None: moduleName = None cache_key=('module-' + str(path)) if self.cache.has_key(cache_key): return self.cache[cache_key] elif True: self.report.info('Reading module file', path) extension=os.path.splitext(path)[-1][1:].lower() parser=self.parsers.get(extension) if (not parser): parser = self.parsers.get('sg') source_and_module=parser.parse(path, moduleName) self.cache[cache_key] = source_and_module[1] return source_and_module[1] def parseSource(self, source, extension, moduleName=None): if moduleName is None: moduleName = None parser=self.parsers.get(extension) source_and_module=parser.parseSource(source, moduleName) return source_and_module[1] def listAvailableLanguages(self): """Returns a list of available languages""" base_dir=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'languages') languages=[] for name in os.listdir(base_dir): if ((not name.startswith('.')) and os.path.isdir(os.path.join(base_dir, name))): languages.append(name) return languages def loadLanguages(self): for language in self.listAvailableLanguages(): self.loadLanguage(language) def normalizeLanguage(self, name): for key_values in self.__class__.ALIASES.items(): key=key_values[0] values=key_values[1] if (key == name): return key elif True: for v in values: if (v == name): return key return None def loadLanguage(self, name): """Loads the given language plug-in and returns a dictionary containing its features.""" name = self.normalizeLanguage(name) if (not (name in self.languages.keys())): language=Language(name, self) self.languages[name] = language return self.languages[name]
class Environment: """ Passes ====== Passes are lists of passes (see 'lambdafactory.passes') that transform the program. The order of passe is important, as some passes depend on each other. It is up to the 'lambdafactory.main.Command' subclass to set up the passes appropriately.""" ALIASES = {'actionscript':['actionscript', 'as', 'ascript'], 'javascript':['javascript', 'js', 'jscript'], 'extern':['extern'], 'python':['python', 'py'], 'php':['php'], 'pnuts':['pnuts']} def __init__ (self): self.factory = None self.program = None self.parsers = {} self.passes = [] self.writer = None self.report = DefaultReporter self.importer = None self.languages = {} self.libraryPaths = [] self.options = {} self.cache = None self.useCache = False self.importer = Importer(self) self.factory = Factory() self.cache = Cache() self.program = self.factory.createProgram() def addLibraryPath(self, path): self.libraryPaths.append(path) def addParser(self, parser, extensions): for ext in extensions: self.parsers[ext.lower()] = parser def addImporter(self, importer): pass def addPass(self, programPass): self.passes.append(programPass) programPass.setEnvironment(self) def getPass(self, name): name = name.lower() for p in self.passes: if (p.getName().lower() == name): return p def getPasses(self): return self.passes def runPasses(self, program): for p in self.passes: self.report.trace('Running pass {0}'.format(p.__class__.__name__)) p.run(program) def getFactory(self): return self.factory def importModule(self, moduleName, importModule=None): if importModule is None: importModule = True assert(self.program) if (importModule and (not self.program.hasModuleWithName(moduleName))): module=self.importer.importModule(moduleName) if module: self.program.addModule(module) return module elif True: return self.program.getModule(moduleName) def parseFile(self, path, moduleName=None): if moduleName is None: moduleName = None f=open(path, 'rb') text=f.read() f.close() return self.parseString(text, path, moduleName) def parseString(self, text, path, moduleName=None): if moduleName is None: moduleName = None source_and_module=self.cache.getFromContent(text) if ((not self.useCache) or (not source_and_module)): extension=path.split('.')[-1] parser=self.parsers.get(extension) if (not parser): parser = self.parsers.get('sg') source_and_module = parser.parseString(text, moduleName, path) if source_and_module[1]: res=[source_and_module[0], source_and_module[1].copy().detach()] assert((res[0] == text)) res[1].setSource(res[0]) if self.useCache: self.cache.set(res) elif True: error(('Could not parse file: ' + path)) elif True: info('Parsing from cache {0}: {1}'.format(self.cache.getKeyForContent(source_and_module[0]), path)) clear_dataflow=ClearDataFlow() clear_dataflow.run(source_and_module[1]) return source_and_module[1] def listAvailableLanguages(self): """Returns a list of available languages by introspecting the modules""" base_dir=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'languages') languages=[] for name in os.listdir(base_dir): if (((not name.startswith('.')) and os.path.isdir(os.path.join(base_dir, name))) and (not name.startswith('_'))): languages.append(name) return languages def loadLanguages(self): for language in self.listAvailableLanguages(): self.loadLanguage(language) def normalizeLanguage(self, name): for key_values in self.__class__.ALIASES.items(): key=key_values[0] values=key_values[1] if (key == name): return key elif True: for v in values: if (v == name): return key return None def loadLanguage(self, name): """Loads the given language plug-in and returns a dictionary containing its features.""" name = self.normalizeLanguage(name) if (not (name in self.languages.keys())): language=Language(name, self) self.languages[name] = language return self.languages[name]