| """Independent recursive tree evaluator: no bytecode compiler or VM calls.""" |
| from .runtime import ICLError,RuntimeContext,checked_binary,checked_unary,builtin,BUILTINS,digest |
| from .checker import validate_value |
| class Returned(Exception): |
| def __init__(self,value):self.value=value |
| class Scope: |
| def __init__(self,parent=None):self.parent=parent;self.values={} |
| def get(self,name): |
| if name in self.values:return self.values[name] |
| if self.parent is not None:return self.parent.get(name) |
| raise ICLError('NAME','undefined '+name) |
| def set(self,name,val): |
| if name in self.values:self.values[name]=val |
| elif self.parent is not None:self.parent.set(name,val) |
| else:raise ICLError('NAME','undefined assignment '+name) |
|
|
| def execute_tree(program,entry='main',args=None,limits=None,policy=None): |
| ctx=RuntimeContext(limits,policy);fs={f['name']:f for f in program['functions']};depth=0 |
| def ex(x,scope): |
| chain=[];cur=scope |
| while cur is not None:chain.append(cur.values);cur=cur.parent |
| ctx.step('tree.'+x['kind'],inputs={'scope':chain,'prng':ctx.prng}) |
| event=ctx.trace[-1] |
| try: |
| value=_ex(x,scope);event['output_hash']=digest(value);event['state_ref']=event['output_hash'];return value |
| except ICLError as error:event['error_code']=error.code;raise |
| def _ex(x,scope): |
| k=x['kind'] |
| if k=='literal':return x['value'] |
| if k=='var':return scope.get(x['name']) |
| if k=='unary':return checked_unary(x['op'],ex(x['expr'],scope)) |
| if k=='binary': |
| a=ex(x['left'],scope) |
| if x['op']=='&&' and a is False:return False |
| if x['op']=='||' and a is True:return True |
| return ctx.check_value(checked_binary(x['op'],a,ex(x['right'],scope))) |
| if k=='call': |
| aa=[ex(v,scope) for v in x['args']] |
| return ctx.check_value(builtin(x['name'],aa,ctx) if x['name'] in BUILTINS else call(x['name'],aa)) |
| if k in ('list','tuple'):return ctx.check_value([ex(v,scope) for v in x['items']]) |
| if k=='record':return ctx.check_value({n:ex(x['fields'][n],scope) for n in sorted(x['fields'])}) |
| if k=='index': |
| a=ex(x['target'],scope);i=ex(x['index'],scope) |
| if i<0 or i>=len(a):raise ICLError('BOUNDS','index out of bounds') |
| return a[i] |
| if k=='field':return ex(x['target'],scope)[x['name']] |
| raise ICLError('UNSUPPORTED_OP',k) |
| def block(ss,parent): |
| scope=Scope(parent) |
| for s in ss: |
| k=s['kind'];ctx.step('tree.'+k) |
| if k=='let':scope.values[s['name']]=ex(s['expr'],scope) |
| elif k=='assign':scope.set(s['name'],ex(s['expr'],scope)) |
| elif k=='return':raise Returned(ex(s['expr'],scope)) |
| elif k=='expr':ex(s['expr'],scope) |
| elif k=='if':block(s['then'] if ex(s['cond'],scope) else s['else'],scope) |
| elif k=='while': |
| count=0 |
| while ex(s['cond'],scope): |
| if count>=s['limit']:raise ICLError('LOOP_LIMIT','declared iteration bound exceeded') |
| count+=1;block(s['body'],scope) |
| else:raise ICLError('UNSUPPORTED_OP',k) |
| def call(name,aa): |
| nonlocal depth |
| if name not in fs:raise ICLError('NAME','entry/function missing '+name) |
| f=fs[name] |
| if len(aa)!=len(f['params']):raise ICLError('TYPE','function argument count') |
| depth+=1 |
| if depth>ctx.limits['max_stack']:raise ICLError('STACK_LIMIT','call stack budget') |
| env=Scope() |
| for (n,t),v in zip(f['params'],aa):validate_value(v,t,ctx);env.values[n]=v |
| try:block(f['body'],env) |
| except Returned as r:validate_value(r.value,f['return_type'],ctx);return r.value |
| finally:depth-=1 |
| raise ICLError('RETURN','function reached end') |
| try:value=call(entry,args or []) |
| except RecursionError:raise ICLError('STACK_LIMIT','host recursion boundary reached') |
| ctx.check_value(value) |
| return {'value':value,'trace':ctx.trace,'effects':ctx.effects,'steps':ctx.steps} |
|
|
