def main(argv):
try:
action = argv[1]
except IndexError:
raise RuntimeError('Action required')
if action == 'py': # Prints the module
# Called by asdl/run.sh py-cpp
schema_path = argv[2]
app_types = {'id': asdl.UserType('id_kind_asdl', 'Id_t')}
with open(schema_path) as f:
schema_ast, type_lookup = front_end.LoadSchema(f, app_types)
root = sys.modules[__name__]
# NOTE: We shouldn't pass in app_types for arith.asdl, but this is just a
# demo.
py_meta.MakeTypes(schema_ast, root, type_lookup)
log('AST for this ASDL schema:')
schema_ast.Print(sys.stdout, 0)
print()
log('Dynamically created a Python module with these types:')
for name in dir(root):
print('\t' + name)
if 1:
# NOTE: It can be pickled, but not marshaled
import marshal
import cPickle
print(dir(marshal))
out_path = schema_path + '.pickle'
with open(out_path, 'w') as f:
#marshal.dump(type_lookup, f)
# Version 2 is the highest protocol for Python 2.7.
cPickle.dump(type_lookup.runtime_type_lookup, f, protocol=2)
print('runtime_type_lookup:')
for name, desc in type_lookup.runtime_type_lookup.items():
print(name)
print(desc)
print()
print('Wrote %s' % out_path)
elif action == 'arith-format': # pretty printing
expr = argv[2]
obj = typed_arith_parse.ParseShell(expr)
tree = obj.PrettyTree()
#treee= ['hi', 'there', ['a', 'b'], 'c']
f = fmt.DetectConsoleOutput(sys.stdout)
fmt.PrintTree(tree, f)
print()
# Might need to print the output?
# out.WriteToFile?
else:
raise RuntimeError('Invalid action %r' % action)
def main(argv):
try:
action = argv[1]
except IndexError:
raise RuntimeError('Action required')
if action == 'py': # Prints the module
schema_path = argv[2]
with open(schema_path) as f:
module = asdl.parse(f)
app_types = {'id': asdl.UserType(Id)}
type_lookup = asdl.ResolveTypes(module, app_types)
# Note this is a big tree. But we really want a graph of pointers to
# instances.
# Type(name, Product(...))
# Type(name, Sum([Constructor(...), ...]))
#print(module)
root = sys.modules[__name__]
# NOTE: We shouldn't pass in app_types for arith.asdl, but this is just a
# demo.
py_meta.MakeTypes(module, root, type_lookup)
print('Dynamically created a Python module with these types:')
for name in dir(root):
print('\t' + name)
elif action == 'arith-encode': # oheap encoding
expr = argv[2]
out_path = argv[3]
obj = arith_parse.ParseShell(expr)
print('Encoding %r into binary:' % expr)
print(obj)
enc = encode.Params()
with open(out_path, 'wb') as f:
out = encode.BinOutput(f)
encode.EncodeRoot(obj, enc, out)
elif action == 'arith-format': # pretty printing
expr = argv[2]
obj = arith_parse.ParseShell(expr)
#out = fmt.TextOutput(sys.stdout)
tree = fmt.MakeTree(obj)
#treee= ['hi', 'there', ['a', 'b'], 'c']
f = fmt.DetectConsoleOutput(sys.stdout)
fmt.PrintTree(tree, f)
print()
# Might need to print the output?
# out.WriteToFile?
else:
raise RuntimeError('Invalid action %r' % action)
def _ParseAndMakeTypes(schema_path, root):
module = asdl.parse(schema_path)
app_types = {}
# Check for type errors
if not asdl.check(module, app_types):
raise AssertionError('ASDL file is invalid')
py_meta.MakeTypes(module, root, app_types)
def _ParseAndMakeTypes(f, root):
module = asdl.parse(f)
app_types = {'id': asdl.UserType(Id)}
# Check for type errors
if not asdl.check(module, app_types):
raise AssertionError('ASDL file is invalid')
py_meta.MakeTypes(module, root, app_types)
def _ParseAndMakeTypes(f, root):
# TODO: A better syntax for this might be:
#
# id = external
#
# in osh.asdl. Then we can show an error if it's not provided.
app_types = {'id': asdl.UserType(Id)}
module = asdl.parse(f)
# Check for type errors
if not asdl.check(module, app_types):
raise AssertionError('ASDL file is invalid')
py_meta.MakeTypes(module, root, app_types)
def _ParseAndMakeTypes(schema_path, root):
module = asdl.parse(schema_path)
app_types = {
'identifier': asdl.UserType(Identifier),
'bytes': asdl.UserType(Bytes),
'object': asdl.UserType(PyObject),
'constant': asdl.UserType(Constant),
'singleton': asdl.UserType(Singleton),
}
# Check for type errors
if not asdl.check(module, app_types):
raise AssertionError('ASDL file is invalid')
py_meta.MakeTypes(module, root, app_types)
def main(argv):
try:
action = argv[1]
except IndexError:
raise RuntimeError('Action required')
if action == 'py':
schema_path = argv[2]
module = asdl.parse(schema_path)
root = sys.modules[__name__]
# NOTE: We shouldn't pass in app_types for arith.asdl, but this is just a
# demo.
py_meta.MakeTypes(module, root, app_types={'id': asdl.UserType(Id)})
print(dir(root))
elif action == 'arith-encode':
expr = argv[2]
out_path = argv[3]
obj = arith_parse.ParseShell(expr)
print('Encoding %r into binary:' % expr)
print(obj)
enc = encode.Params()
with open(out_path, 'wb') as f:
out = encode.BinOutput(f)
encode.EncodeRoot(obj, enc, out)
elif action == 'arith-format':
expr = argv[2]
obj = arith_parse.ParseShell(expr)
#out = fmt.TextOutput(sys.stdout)
tree = fmt.MakeTree(obj)
#treee= ['hi', 'there', ['a', 'b'], 'c']
fmt.PrintTree(tree, sys.stdout)
# Might need to print the output?
# out.WriteToFile?
else:
raise RuntimeError('Invalid action %r' % action)
from core.id_kind import Id
def _LoadSchema(f):
module = asdl.parse(f)
app_types = {'id': asdl.UserType(Id)}
type_lookup = asdl.ResolveTypes(module, app_types)
# Check for type errors
if not asdl.check(module, app_types):
raise AssertionError('ASDL file is invalid')
return module, type_lookup
f = util.GetResourceLoader().open('core/runtime.asdl')
root = sys.modules[__name__]
module, type_lookup = _LoadSchema(f)
if 0:
py_meta.MakeTypes(module, root, type_lookup)
else:
# Exported for the generated code to use
TYPE_LOOKUP = type_lookup
# Get the types from elsewhere
from _devbuild.gen import runtime_asdl
py_meta.AssignTypes(runtime_asdl, root)
f.close()
def IdInstance(i):
return _ID_INSTANCES[i]
#
# Instantiate osh/types.asdl
#
f = util.GetResourceLoader().open('osh/types.asdl')
_asdl_module, _type_lookup = asdl.LoadSchema(f, {}) # no app_types
types = _AsdlModule()
if 0:
py_meta.MakeTypes(_asdl_module, types, _type_lookup)
else:
# Exported for the generated code to use
TYPES_TYPE_LOOKUP = _type_lookup
# Get the types from elsewhere
from _devbuild.gen import types_asdl
py_meta.AssignTypes(types_asdl, types)
f.close()
# Id -> bool_arg_type_e
BOOL_ARG_TYPES = {} # type: dict
# Used by test_builtin.py
TEST_UNARY_LOOKUP = {}
#!/usr/bin/python
"""
arith_ast.py
"""
import os
import sys
from asdl import asdl_ as asdl
from asdl import py_meta
this_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
schema_path = os.path.join(this_dir, 'arith.asdl')
with open(schema_path) as f:
module = asdl.parse(f)
root = sys.modules[__name__]
py_meta.MakeTypes(module, root)
#!/usr/bin/env python
"""
arith_ast.py
"""
import sys
from asdl import front_end
from asdl import py_meta
from core import util
f = util.GetResourceLoader().open('asdl/arith.asdl')
_asdl_module, _type_lookup = front_end.LoadSchema(f, {}) # no app_types
f.close()
root = sys.modules[__name__]
py_meta.MakeTypes(_asdl_module, root, _type_lookup)
