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]
