def evaluate_interactive(self,env = None):
## use a persistent environment for interactive interpreter
if ( not env ):
env = Environment( self.call_stack, self.function_map, \
self.builtin_map, self.debug )
env.call_function("__toplevel__") ##some context
## use this from the interactive-interpreter
rval = self.ast.evaluate(env)
return [ rval, env ]
def __init__(self,lexer, debug = False,safe_mode=False,update=True,stacksize=500,env=None):
DebugUtils.__init__(self,debug)
self.SAFE_MODE = safe_mode
self.debug = debug
self.MAX_REC_DEPTH = 10000 #for Python
self.stacksize = stacksize #for Ezhil stacksize
self.lexer=lexer
self.ast=None
self.function_map = NoClobberDict()#parsed functions
self.builtin_map = NoClobberDict() #pointers to builtin functions
self.call_stack = list() #call stack
if not env:
self.env = Environment( self.call_stack, self.function_map, \
self.builtin_map, self.debug, self.stacksize )
else:
self.env = env
sys.setrecursionlimit( self.MAX_REC_DEPTH ) # have a large enough Python stack
## use the default Exprs parser.
lang_parser = Parser(self.lexer,self.function_map, \
self.builtin_map, self.debug )
self.parser = lang_parser
## run the installation code last
self.install_builtins()
self.install_blind_builtins()
if update :
## update globals
global global_interpreter
global_interpreter = self
def evaluate(self):
env = Environment( self.call_stack, self.function_map, \
self.builtin_map, self.debug, int(self.MAX_REC_DEPTH/10) )
env.call_function("__toplevel__") ##some context
return self.ast.evaluate(env)
def evaluate(self):
env = Environment( self.call_stack, self.function_map, \
self.builtin_map, self.debug, int(self.MAX_REC_DEPTH/10) )
env.call_function("__toplevel__") ##some context
return self.ast.evaluate(env)
java_import(gateway.jvm, "org.apache.spark.SparkConf")
java_import(gateway.jvm, "org.apache.spark.api.java.*")
java_import(gateway.jvm, "org.apache.spark.api.python.*")
java_import(gateway.jvm, "org.apache.spark.mllib.api.python.*")
java_import(gateway.jvm, "org.apache.spark.sql.*")
java_import(gateway.jvm, "org.apache.spark.sql.hive.*")
java_import(gateway.jvm, "scala.Tuple2")
jconf = entry_point.getSparkConf()
jsc = entry_point.getJavaSparkContext()
job_id = entry_point.getJobId()
javaEnv = entry_point.getEnv()
working_dir = javaEnv.workingDir() or '/tmp/amaterasu'
env = Environment(javaEnv.name(), javaEnv.master(), javaEnv.inputRootPath(),
javaEnv.outputRootPath(), working_dir,
javaEnv.configuration())
conf = SparkConf(_jvm=gateway.jvm, _jconf=jconf)
sc = SparkContext(jsc=jsc, gateway=gateway, conf=conf)
spark = SparkSession(sc, entry_point.getSparkSession())
ama_context = AmaContext(sc, spark, job_id, env)
while True:
actionData = queue.getNext()
resultQueue = entry_point.getResultQueue(actionData._2())
actionSource = actionData._1()
tree = ast.parse(actionSource)
exports = actionData._3()
class Interpreter(DebugUtils):
""" when you add new language feature, add a AST class
and its evaluate methods. Also add a parser method """
def __init__(self,lexer, debug = False,safe_mode=False,update=True,stacksize=500,env=None):
DebugUtils.__init__(self,debug)
self.SAFE_MODE = safe_mode
self.debug = debug
self.MAX_REC_DEPTH = 10000 #for Python
self.stacksize = stacksize #for Ezhil stacksize
self.lexer=lexer
self.ast=None
self.function_map = NoClobberDict()#parsed functions
self.builtin_map = NoClobberDict() #pointers to builtin functions
self.call_stack = list() #call stack
if not env:
self.env = Environment( self.call_stack, self.function_map, \
self.builtin_map, self.debug, self.stacksize )
else:
self.env = env
sys.setrecursionlimit( self.MAX_REC_DEPTH ) # have a large enough Python stack
## use the default Exprs parser.
lang_parser = Parser(self.lexer,self.function_map, \
self.builtin_map, self.debug )
self.parser = lang_parser
## run the installation code last
self.install_builtins()
self.install_blind_builtins()
if update :
## update globals
global global_interpreter
global_interpreter = self
def get_fname(self):
return self.lexer.fname
def reset(self):
""" reset lexer and parser """
self.parser.reset()
self.lexer.reset()
return
def change_parser(self,parser_ctor):
""" change the parser to your-cool-language using
a lambda function parser_ctor the constructor """
lang_parser = parser_ctor(self.lexer,self.function_map, \
self.builtin_map, self.debug )
self.parser = lang_parser
return True
def list_functions(self,*args):
if ( not args ):
user_prefix = None
else:
user_prefix = args[0]
print(u"######### Builtin Function ########")
if not user_prefix:
pos = 0
for xpos,fcn in enumerate(self.builtin_map.keys()):
if ( user_prefix and not fcn.startswith(user_prefix) ):
continue
pos = pos + 1
print(u"%03d> %s"%(pos,unicode(fcn)))
return
print(u"######### Functions - Library + User defined - ########")
pos = 0
for xpos,fcn in enumerate(self.function_map.keys()):
if ( user_prefix and not fcn.startswith(user_prefix) ):
continue
pos = pos + 1
print(u"%03d> %s"%(pos,unicode(fcn)))
def add_blind_fcns(self, bfn, b):
""" an internal method to reduce repetition """
if ( not inspect.ismethod(bfn)
and not inspect.isclass(bfn)
and isinstance(bfn, collections.Callable) ):
self.dbg_msg("adding: "+b);
self.builtin_map[b] = BlindBuiltins( bfn, b);
else:
self.dbg_msg("skipping: "+b);
return
def install_blind_builtins(self):
""" we dont know the arity of these functions,
hence we call-em the blind builtins, but we
still add them to the builtin_map """
for b in dir(os):
if self.SAFE_MODE:
break
bfn = getattr( os ,b)
if str(b).find('exec') >= 0 or str(b).find('spawn') >= 0:
continue
if PYTHON3 and b == u"replace":
continue
self.add_blind_fcns( bfn, b)
for b in dir(sys):
bfn = getattr( sys ,b)
self.add_blind_fcns( bfn, b)
@staticmethod
def ezhil_assert( x ):
# we raise Exception(u'Assertion failed!') further up stack
assert x
return True
# file IO functions - 6 total
@staticmethod
def file_open(*args):
try:
args = list(args)
if ( len(args) < 2 ):
args.append('r') #default op = read
if ( len(args) < 3 ):
args.append('utf-8') #default encoding = utf-8
fp = codecs.open(*args)
return fp
except Exception as e:
print(u"WARNING : cannot open file %s with exception %s",args[0],str(e))
return -1
@staticmethod
def file_close(*args):
try:
assert( len(args) == 1 )
assert( hasattr(args[0],'close') )
args[0].close()
except Exception as e:
print(u"WARNING: file_close failed with exception %s"%str(e))
return -1
return 0
@staticmethod
def file_read(*args):
assert( len(args) == 1 )
assert( hasattr(args[0],'read') )
return String( args[0].read() )
@staticmethod
def file_readlines(*args):
assert( len(args) == 1 )
assert( hasattr(args[0],'readlines') )
return args[0].readlines()
@staticmethod
def file_write(*args):
assert( len(args) == 2 )
assert( hasattr(args[0],'write') )
return args[0].write( args[1] )
@staticmethod
def file_writelines(*args):
assert( len(args) == 2 )
assert( hasattr(args[0],'writelines') )
return args[0].writelines(args[1])
# marshalling
@staticmethod
def RAWINPUT(args):
try:
op = raw_input(args)
except KeyboardInterrupt as e :
print(u"\nTo exit the program type : exit or press CTRL + D on your keyboard")
return String("")
return String(op)
@staticmethod
def INPUT(args):
try:
op = (raw_input(args))
except KeyboardInterrupt as e :
print(u"\nTo exit the program type : exit or press CTRL + D on your keyboard")
return Number(0)
if ( isinstance(op,int) or isinstance(op,float) ):
return Number(0.0+op)
return String( op )
@staticmethod
def SPRINTF_worker(*args):
if ( len(args) < 1 ):
raise Exception(u'Not enough arguments to printf() function')
fmt = args[0]
arg = tuple( args[1:] );
opstr = fmt%arg;
return opstr
@staticmethod
def SPRINTF(*args):
opstr = Interpreter.SPRINTF_worker(*args);
return String(opstr)
@staticmethod
def PRINTF(*args):
str_op = Interpreter.SPRINTF_worker(*args);
print(str_op)
return Number(len(str_op))
@staticmethod
def ezhil_reverse(*args):
if ( len(args) != 1 ): raise Exception('One argument alone expected to reverse function')
if ( isinstance( args[0], str ) or isinstance( args[0], unicode) ):
return String(args[0][::-1]) #string-reverse
return list.reverse(args[0])
@staticmethod
def ezhil_pause(*args):
if ( len(args) >= 1 ):
print(args[0])
if ( len(args) < 2 ):
ezhil_sleep( 5 )
else:
ezhil_sleep( args[1] )
return
def add_builtin(self,call_name,call_handle,nargin=1,ta_alias=None):
# make sure you don't clobber yourself
assert not self.builtin_map.get(call_name,None)
if ( nargin == -1 ):
self.builtin_map[call_name] = BlindBuiltins( call_handle, call_name, self.debug)
else:
self.builtin_map[call_name] = BuiltinFunction( call_handle, call_name, nargin, self.debug )
# update the alias if something was supplied
if ( ta_alias ):
assert not self.builtin_map.get(ta_alias,None) #noclobber
self.builtin_map[ta_alias] = self.builtin_map[call_name]
return True
def install_builtins(self):
""" populate with the builtin functions"""
self.builtin_map[u'printf']=BlindBuiltins(Interpreter.PRINTF,u'printf',self.debug)
self.builtin_map[u'sprintf']=BlindBuiltins(Interpreter.SPRINTF,u'sprintf',self.debug)
self.builtin_map['abs']=BlindBuiltins(abs,'abs',self.debug)
self.builtin_map['all']=BlindBuiltins(all,'all',self.debug)
self.builtin_map['any']=BlindBuiltins(any,'any',self.debug)
if not PYTHON3:
self.builtin_map['apply']=BlindBuiltins(apply,'apply',self.debug)
self.builtin_map['buffer']=BlindBuiltins(buffer,'buffer',self.debug)
self.builtin_map['cmp']=BlindBuiltins(cmp,'cmp',self.debug)
self.builtin_map['basestring']=BlindBuiltins(str,'basestring',self.debug)
self.builtin_map['bin']=BlindBuiltins(bin,'bin',self.debug)
self.builtin_map['bool']=BlindBuiltins(bool,'bool',self.debug)
self.builtin_map['bytearray']=BlindBuiltins(bytearray,'bytearray',self.debug)
self.builtin_map['bytes']=BlindBuiltins(bytes,'bytes',self.debug)
self.builtin_map['callable']=BlindBuiltins(callable,'callable',self.debug)
self.builtin_map['chr']=BlindBuiltins(chr,'chr',self.debug)
#self.builtin_map['classmethod']=BlindBuiltins(classmethod,'classmethod',self.debug)
#self.builtin_map['coerce']=BlindBuiltins(coerce,'coerce',self.debug)
self.builtin_map['compile']=BlindBuiltins(compile,'compile',self.debug)
self.builtin_map['complex']=BlindBuiltins(complex,'complex',self.debug)
self.builtin_map['xor'] = BlindBuiltins(lambda *x: reduce(lambda a,b: a^b,x),'xor',self.debug)
# special ezhil commands
self.builtin_map['copyright']=BlindBuiltins(ezhil_copyright,'copyright',self.debug)
self.builtin_map['version']=BlindBuiltins(ezhil_version,'version',self.debug)
self.builtin_map['credits']=BlindBuiltins(ezhil_credits,'credits',self.debug)
# global interpreter
self.builtin_map['dir']=BlindBuiltins(ezhil_list_functions,'dir',self.debug)
self.builtin_map['delattr']=BlindBuiltins(delattr,'delattr',self.debug)
self.builtin_map['dict']=BlindBuiltins(dict,'dict',self.debug)
self.builtin_map['python_dir']=BlindBuiltins(dir,'python_dir',self.debug)
self.builtin_map['divmod']=BlindBuiltins(divmod,'divmod',self.debug)
self.builtin_map['enumerate']=BlindBuiltins(enumerate,'enumerate',self.debug)
# skip these system functions
self.builtin_map['eval']=BlindBuiltins(ezhil_eval,'eval',self.debug)
self.builtin_map[u'மதிப்பீடு']=self.builtin_map['eval']
self.builtin_map['execute']=BlindBuiltins(ezhil_execute,'execute',self.debug)
self.builtin_map[u'இயக்கு']=self.builtin_map['execute']
self.builtin_map['profile'] = BlindBuiltins(ezhil_profile,'profile',self.debug)
#self.builtin_map['execfile']=BlindBuiltins(execfile,'execfile',self.debug)
#self.builtin_map['exit']=BlindBuiltins(exit,'exit',self.debug)
if not PYTHON3:
self.builtin_map['file']=BlindBuiltins(file,'file',self.debug)
self.builtin_map['intern']=BlindBuiltins(intern,'intern',self.debug)
self.builtin_map['filter']=BlindBuiltins(filter,'filter',self.debug)
self.builtin_map['float']=BlindBuiltins(float,'float',self.debug)
self.builtin_map['format']=BlindBuiltins(format,'format',self.debug)
self.builtin_map['frozenset']=BlindBuiltins(frozenset,'frozenset',self.debug)
self.builtin_map['getattr']=BlindBuiltins(getattr,'getattr',self.debug)
#self.builtin_map['globals']=BlindBuiltins(globals,'globals',self.debug)
self.builtin_map['hasattr']=BlindBuiltins(hasattr,'hasattr',self.debug)
self.builtin_map['hash']=BlindBuiltins(hash,'hash',self.debug)
self.builtin_map['help']=BlindBuiltins(help,'help',self.debug)
self.builtin_map['hex']=BlindBuiltins(hex,'hex',self.debug)
self.builtin_map['id']=BlindBuiltins(id,'id',self.debug)
self.builtin_map['int']=BlindBuiltins(int,'int',self.debug)
self.builtin_map['isinstance']=BlindBuiltins(isinstance,'isinstance',self.debug)
self.builtin_map['issubclass']=BlindBuiltins(issubclass,'issubclass',self.debug)
self.builtin_map['iter']=BlindBuiltins(iter,'iter',self.debug)
self.builtin_map['len']=BlindBuiltins(len,'len',self.debug)
self.builtin_map['license']=BlindBuiltins(ezhil_license,'license',self.debug)
self.builtin_map['long']=BlindBuiltins(int,'long',self.debug)
self.builtin_map['map']=BlindBuiltins(map,'map',self.debug)
#self.builtin_map['max']=BlindBuiltins(max,'max',self.debug)
try:
self.builtin_map['memoryview']=BlindBuiltins(memoryview,'memoryview',self.debug)
except NameError as ie:
if(self.debug):
print(u"Name Error:",unicode(ie))
#self.builtin_map['min']=BlindBuiltins(min,'min',self.debug)
self.builtin_map['next']=BlindBuiltins(next,'next',self.debug)
self.builtin_map['object']=BlindBuiltins(object,'object',self.debug)
self.builtin_map['oct']=BlindBuiltins(oct,'oct',self.debug)
#self.builtin_map['open']=BlindBuiltins(open,'open',self.debug)
self.builtin_map['ord']=BlindBuiltins(ord,'ord',self.debug)
#self.builtin_map['pow']=BlindBuiltins(pow,'pow',self.debug)
self.builtin_map['property']=BlindBuiltins(property,'property',self.debug)
self.builtin_map['quit']=BlindBuiltins(quit,'quit',self.debug)
self.builtin_map['range']=BlindBuiltins(range,'range',self.debug)
if not PYTHON3:
self.builtin_map['reduce']=BlindBuiltins(reduce,'reduce',self.debug)
self.builtin_map['reload']=BlindBuiltins(reload,'reload',self.debug)
self.builtin_map['unicode']=BlindBuiltins(str,'unicode',self.debug)
self.builtin_map['repr']=BlindBuiltins(repr,'repr',self.debug)
self.builtin_map['reversed']=BlindBuiltins(reversed,'reversed',self.debug)
self.builtin_map['round']=BlindBuiltins(round,'round',self.debug)
self.builtin_map['set']=BlindBuiltins(set,'set',self.debug)
self.builtin_map['setattr']=BlindBuiltins(setattr,'setattr',self.debug)
self.builtin_map['slice']=BlindBuiltins(slice,'slice',self.debug)
self.builtin_map['sorted']=BlindBuiltins(sorted,'sorted',self.debug)
self.builtin_map['staticmethod']=BlindBuiltins(staticmethod,'staticmethod',self.debug)
self.builtin_map['sum']=BlindBuiltins(sum,'sum',self.debug)
self.builtin_map['super']=BlindBuiltins(super,'super',self.debug)
self.builtin_map['tuple']=BlindBuiltins(tuple,'tuple',self.debug)
self.builtin_map['type']=BlindBuiltins(type,'type',self.debug)
self.builtin_map['unichr']=BlindBuiltins(chr,'unichr',self.debug)
self.builtin_map['vars']=BlindBuiltins(vars,'vars',self.debug)
if not PYTHON3:
self.builtin_map['xrange']=BlindBuiltins(xrange,'xrange',self.debug)
self.builtin_map['zip']=BlindBuiltins(zip,'zip',self.debug)
# common/generic functions
self.builtin_map['__getitem__']=BlindBuiltins(ezhil_getitem,"__getitem__")
self.builtin_map['__setitem__']=BuiltinFunction(ezhil_setitem,"__setitem__",3)
#file-IO functions
self.builtin_map["file_open"]=BlindBuiltins(Interpreter.file_open,"file_open")
self.builtin_map["file_close"]=BuiltinFunction(Interpreter.file_close,"file_close")
self.builtin_map["file_read"]=BuiltinFunction(Interpreter.file_read,"file_read")
self.builtin_map["file_readlines"]=BuiltinFunction(Interpreter.file_readlines,"file_readlines")
self.builtin_map["file_write"]=BuiltinFunction(Interpreter.file_write,"file_write",2)
self.builtin_map["file_writelines"]=BuiltinFunction(Interpreter.file_writelines,"file_writelines",2)
# input statements
self.builtin_map["input"]=BuiltinFunction(Interpreter.INPUT,"input")
self.builtin_map["raw_input"]=BuiltinFunction(Interpreter.RAWINPUT,"raw_input")
# assert
self.builtin_map["assert"]=BuiltinFunction(Interpreter.ezhil_assert,"assert")
# str - used for simple serialization in Ezhil
self.builtin_map["str"]=BuiltinFunction(str,"str")
# sys_platform - used for Windows/Linux identification
self.builtin_map["sys_platform"]=BuiltinFunction(lambda : sys.platform,"sys_platform",padic=0)
# sleep/pause
self.builtin_map["sleep"]=BuiltinFunction(ezhil_sleep,"sleep")
self.builtin_map["pause"]=BlindBuiltins(Interpreter.ezhil_pause,"pause")
# date/time
self.add_builtin("date_time",ezhil_date_time,nargin=0,ta_alias=u"தேதி_நேரம்")
self.add_builtin("time",time.time,nargin=0,ta_alias=u"நேரம்")
self.add_builtin("ctime",time.ctime,nargin=1,ta_alias=u"cநேரம்")
self.add_builtin("clock",time.time,nargin=0)
# islist, isnumber predicates
self.add_builtin("islist",ezhil_islist,nargin=1,ta_alias=u"பட்டியலா")
self.add_builtin("isnumber",ezhil_isnumber,nargin=1,ta_alias=u"எண்ணா")
# random functions
aslist = True;
self.builtin_map["choice"]=BlindBuiltins(random.choice,"choice",self.debug,aslist)
self.builtin_map["random"]=BuiltinFunction(random.random,"random",0)
self.builtin_map["seed"]=BuiltinFunction(random.seed,"seed")
self.builtin_map["randint"]=BuiltinFunction(random.randint,"randint",2)
# math functions
self.builtin_map["acos"]=BuiltinFunction(acos,"acos")
self.builtin_map["asin"]=BuiltinFunction(asin,"asin")
self.builtin_map["atan"]=BuiltinFunction(atan,"atan")
self.builtin_map["atan2"]=BuiltinFunction(atan2,"atan2")
self.builtin_map["ceil"]=BuiltinFunction(ceil,"ceil")
self.builtin_map["cos"]=BuiltinFunction(cos,"cos")
self.builtin_map["cosh"]=BuiltinFunction(cosh,"cosh")
self.builtin_map["degrees"]=BuiltinFunction(degrees,"degrees")
self.builtin_map["e"]=BuiltinFunction(lambda : e,"e",0)
self.builtin_map["exp"]=BuiltinFunction(exp,"exp")
self.builtin_map["fabs"]=BuiltinFunction(fabs,"fabs")
self.builtin_map["floor"]=BuiltinFunction(floor,"floor")
self.builtin_map["fmod"]=BuiltinFunction(fmod,"fmod",2)
self.builtin_map["frexp"]=BuiltinFunction(frexp,"frexp")
self.builtin_map["hypot"]=BuiltinFunction(hypot,"hypot",2)
self.builtin_map["ldexp"]=BuiltinFunction(ldexp,"ldexp")
self.builtin_map["log"]=BuiltinFunction(log,"log")
self.builtin_map["log10"]=BuiltinFunction(log10,"log10")
self.builtin_map["modf"]=BuiltinFunction(modf,"modf",2)
self.builtin_map["pi"]=BuiltinFunction(lambda : pi,"pi",0)
self.builtin_map["pow"]=BuiltinFunction(pow,"pow",2)
self.builtin_map["radians"]=BuiltinFunction(radians,"radians")
self.builtin_map["sin"]=BuiltinFunction(sin,"sin")
self.builtin_map["sinh"]=BuiltinFunction(sinh,"sinh")
self.builtin_map["sqrt"]=BuiltinFunction(sqrt,"sqrt")
self.builtin_map["tan"]=BuiltinFunction(tan,"tan")
self.builtin_map["tanh"]=BuiltinFunction(tanh,"tanh")
self.builtin_map["max"]=BuiltinFunction(max,"max",2)
self.builtin_map["min"]=BuiltinFunction(min,"min",2)
#self.builtin_map["exit"]=BuiltinFunction(min,"exit",1)
# turtle functions - optional -
try:
# turtle graphics
from EZTurtle import EZTurtle
turtle_attrib = EZTurtle.functionAttributes();
for nargs,fcnName in list(turtle_attrib.items()):
for vv in fcnName:
turtlefcn = u"turtle_"+vv;
if ( self.debug ): print(nargs, vv)
if ( nargs == -1 ):
self.builtin_map[turtlefcn] = BlindBuiltins(getattr(EZTurtle, vv),vv,self.debug)
else:
self.builtin_map[turtlefcn] = BuiltinFunction( getattr( EZTurtle, vv ), turtlefcn, nargs )
except ImportError as ie:
if ( self.debug ):
print(u"Cannot Import EZTurtle module; ignoring for now")
# all builtin functions should pass the following test:
# for attr in dir(module):
# assert callable( getattr( module, attr ) )
# non-callable attributes cannot be in the builtins list
# string module builtins
self.builtin_map["find"] = BuiltinFunction(string.find,"find",2)
if not PYTHON3:
self.builtin_map["atof"] = BuiltinFunction(string.atof,"atof",1)
self.builtin_map["atof_error"] = BuiltinFunction(string.atof_error,"atof_error",1)
self.builtin_map["atoi"] = BuiltinFunction(string.atoi,"atoi",1)
self.builtin_map["atoi_error"] = BuiltinFunction(string.atoi_error,"atoi_error",1)
self.builtin_map["atol"] = BuiltinFunction(string.atol,"atol",1)
self.builtin_map["atol_error"] = BuiltinFunction(string.atol_error,"atol_error",1)
self.builtin_map["capitalize"] = BuiltinFunction(string.capitalize,"capitalize",1)
self.builtin_map["capwords"] = BuiltinFunction(string.capwords,"capwords",1)
self.builtin_map["center"] = BuiltinFunction(string.center,"center",1)
self.builtin_map["count_string"] = BuiltinFunction(string.count,"count",1)
self.builtin_map["expandtabs"] = BuiltinFunction(string.expandtabs,"expandtabs",1)
self.builtin_map["index_string"] = BuiltinFunction(string.index,"index",2)
if not PYTHON3:
self.builtin_map["index_error"] = BuiltinFunction(string.index_error,"index_error",1)
self.builtin_map["join"] = BuiltinFunction(str.join,"join",1)
if not PYTHON3:
self.builtin_map["joinfields"] = BuiltinFunction(string.joinfields,"joinfields",1)
self.builtin_map["ljust"] = BuiltinFunction(string.ljust,"ljust",1)
self.builtin_map["lower"] = BuiltinFunction(string.lower,"lower",1)
self.builtin_map["lstrip"] = BuiltinFunction(string.lstrip,"lstrip",1)
if not PYTHON3:
self.builtin_map["maketrans"] = BuiltinFunction(string.maketrans,"maketrans",1)
self.builtin_map["replace"] = BuiltinFunction(string.replace,"replace",3)
self.builtin_map["rfind"] = BuiltinFunction(string.rfind,"rfind",2)
self.builtin_map["rindex"] = BuiltinFunction(string.rindex,"rindex",1)
self.builtin_map["rjust"] = BuiltinFunction(string.rjust,"rjust",1)
self.builtin_map["rsplit"] = BuiltinFunction(string.rsplit,"rsplit",1)
self.builtin_map["rstrip"] = BuiltinFunction(string.rstrip,"rstrip",1)
self.builtin_map["split"] = BuiltinFunction(string.split,"split",2)
if not PYTHON3:
self.builtin_map["splitfields"] = BuiltinFunction(string.splitfields,"splitfields",1)
self.builtin_map["strip"] = BuiltinFunction(string.strip,"strip",1)
self.builtin_map["swapcase"] = BuiltinFunction(str.swapcase,"swapcase",1)
self.builtin_map["translate"] = BuiltinFunction(str.translate,"translate",1)
self.builtin_map["upper"] = BuiltinFunction(str.upper,"upper",1)
self.builtin_map["zfill"] = BuiltinFunction(str.zfill,"zfill",2)
# get/set methods are handled by generic __getitem__ and __setitem__
# list methods - first argument, when required, is always a list obj
self.builtin_map["append"] = BuiltinFunction(list.append,"append",2)
self.builtin_map["insert"] = BuiltinFunction(list.insert,"insert",3)
self.builtin_map["index"] = BuiltinFunction(list.index,"index",2)
self.builtin_map["list"] = BuiltinFunction(list,"list",0)
self.builtin_map["pop"] = BuiltinFunction(list.pop,"pop",1)
#if PYTHON3:
# self.builtin_map["sort"] = BuiltinFunction(lambda x: sorted(x),"sort",1)
#else:
self.builtin_map["sort"] = BuiltinFunction(list.sort,"sort",1)
self.builtin_map["count"]= BuiltinFunction(list.count,"count",2)
self.builtin_map["extend"]= BuiltinFunction(list.extend,"extend",2)
self.builtin_map["reverse"]= BuiltinFunction(Interpreter.ezhil_reverse,"reverse",1)
self.builtin_map["pop_list"] = BuiltinFunction(list.pop,"pop",1)
# dictionary methods - first argument, when required, is always a dict obj
self.builtin_map["clear"]= BuiltinFunction(dict.clear,"clear",1)
self.builtin_map["copy"]= BuiltinFunction(dict.copy,"copy",1)
self.builtin_map["fromkeys"]= BuiltinFunction(dict.fromkeys,"fromkeys",1)
self.builtin_map["items"]= BuiltinFunction(dict.items,"items",1)
if not PYTHON3:
self.builtin_map["has_key"]= BuiltinFunction(dict.has_key,"has_key",1)
self.builtin_map["iteritems"]= BuiltinFunction(dict.iteritems,"iteritems",1)
self.builtin_map["iterkeys"]= BuiltinFunction(dict.iterkeys,"iterkeys",1)
self.builtin_map["itervalues"]= BuiltinFunction(dict.itervalues,"itervalues",1)
self.builtin_map["pop_dict"]= BuiltinFunction(dict.pop,"pop",1)
self.builtin_map["popitem"]= BuiltinFunction(dict.popitem,"popitem",1)
self.builtin_map["setdefault"]= BuiltinFunction(dict.setdefault,"setdefault",1)
if PYTHON3:
self.builtin_map["keys"]= BuiltinFunction(lambda x: list(dict.keys(x)),"keys",1)
self.builtin_map["values"]= BuiltinFunction(lambda x: list(dict.values(x)),"values",1)
else:
self.builtin_map["keys"]= BuiltinFunction(dict.keys,"keys",1)
self.builtin_map["values"]= BuiltinFunction(dict.values,"values",1)
self.builtin_map["update"]= BuiltinFunction(dict.update,"update",1)
# URL API's - load except in safe mode
if not self.SAFE_MODE:
Load_URL_APIs( self )
# open-tamil API
# get tamil letters
self.add_builtin("get_tamil_letters",tamil.utf8.get_letters,nargin=1,ta_alias=u"தமிழ்_எழுத்துக்கள்")
self.add_builtin(u"த",tamil.utf8.get_letters,nargin=1)
self.add_builtin("tamil_length",ezhil_tamil_length,nargin=1,ta_alias=u"தநீளம்")
# functions returning constant list of Tamil strings
self.add_builtin("tamil_letters",lambda : tamil.utf8.tamil_letters,
nargin=0,ta_alias=u"தமிழ்எழுத்து")
self.add_builtin("tamil_uyir",lambda : tamil.utf8.uyir_letters,
nargin=0,ta_alias=u"உயிர்எழுத்து")
self.add_builtin("tamil_mei",lambda: tamil.utf8.mei_letters,
nargin=0,ta_alias=u"மெய்எழுத்து")
self.add_builtin("tamil_kuril",lambda: tamil.utf8.kuril_letters,
nargin=0,ta_alias=u"குரில்எழுத்து")
self.add_builtin("tamil_nedil",lambda: tamil.utf8.nedil_letters,
nargin=0,ta_alias=u"நேடில்எழுத்து")
self.add_builtin("tamil_vallinam",lambda: tamil.utf8.vallinam_letters,
nargin=0,ta_alias=u"வல்லினம்எழுத்து")
self.add_builtin("tamil_mellinam",lambda: tamil.utf8.mellinam_letters,
nargin=0,ta_alias=u"மெல்லினம்")
self.add_builtin("tamil_idayinam",lambda: tamil.utf8.idayinam_letters,
nargin=0,ta_alias=u"இடைனம்எழுத்து")
self.add_builtin("tamil_agaram",lambda: tamil.utf8.agaram_letters,
nargin=0,ta_alias=u"அகரம்எழுத்து")
self.add_builtin("tamil_uyirmei",lambda: tamil.utf8.uyirmei_letters,
nargin=0,ta_alias=u"உயிர்மெய்எழுத்து")
self.add_builtin("tamil_istamil_prefix",tamil.utf8.istamil_prefix,
nargin=1)
self.add_builtin("tamil_all_tamil", tamil.utf8.all_tamil,
nargin=1,ta_alias=u"தனித்தமிழா")
self.add_builtin("tamil_hastamil",tamil.utf8.has_tamil,
nargin=1,ta_alias=u"தமிழ்கொண்டதா")
self.add_builtin("tamil_reverse_word",tamil.utf8.reverse_word,
nargin=1,ta_alias=u"அந்தாதிமாற்று")
return True
def __del__(self):
if (self.debug): print("deleting Interpreter...")
def __repr__(self):
rval = u"[Interpreter: "
rval = rval + u"[Functions["
for k in list(self.function_map.keys()):
rval = rval + u"\n "+ unicode(self.function_map[k])
rval = rval +u"]] "+ unicode(self.ast) +u"]\n"
return rval
def parse(self):
""" parser routine """
self.ast = self.parser.parse()
return self.ast
def evaluate(self):
try:
if self.SAFE_MODE:
TransformSafeModeFunctionCheck(interpreter=self,debug=self.debug)
# always verify semantics before running code
#if ( self.debug ): print(self.ast )
TransformSemanticAnalyzer(interpreter=self, debug=self.debug)
# constant fold
#for i in range(0,2):
# TransformConstantFolder( interpreter = self, debug=self.debug)
if ( len(self.call_stack) == 0 ):
self.env.call_function("__toplevel__") ##some context
return self.ast.evaluate(self.env)
except Exception as e:
self.env.unroll_stack()
if ( self.debug ):
traceback.print_tb(sys.exc_info()[2])
raise e
def evaluate_interactive(self,env=None):
## use a persistent environment for interactive interpreter
try:
## use this from the interactive-interpreter
rval = self.ast.evaluate(self.env)
return [ rval, self.env ]
#except RuntimeException as e:
# self.env.unroll_stack()
# #self.env.call_stack.pop()
except Exception as e:
self.env.unroll_stack()
#self.env.call_stack.pop()
print("ERROR : %s"%str(e))
if (self.debug): print(str(self.env))
return [str(e),self.env]
