main.py 59 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177
  1. import modelverse_kernel.primitives as primitive_functions
  2. import modelverse_kernel.compiled as compiled_functions
  3. from modelverse_kernel.request_handler import RequestHandler
  4. import modelverse_jit.jit as jit
  5. import modelverse_jit.intrinsics as jit_intrinsics
  6. import modelverse_jit.jit_primitives as jit_primitives
  7. import modelverse_jit.runtime as jit_runtime
  8. from collections import defaultdict
  9. import sys
  10. import time
  11. if sys.version > '3': # pragma: no cover
  12. string_types = (str,)
  13. else:
  14. string_types = (str, unicode)
  15. class ModelverseKernel(object):
  16. def __init__(self, root):
  17. self.root = root
  18. self.returnvalue = None
  19. # request_handlers is a dictionary of tasknames to dictionaries of operations
  20. # to request handlers. In generics notation:
  21. #
  22. # Dictionary<
  23. # Username,
  24. # Dictionary<
  25. # Operation,
  26. # RequestHandler>>
  27. #
  28. self.request_handlers = {}
  29. self.allow_compiled = True
  30. #self.allow_compiled = False
  31. # Set `self.suggest_function_names` to True to associate global function names
  32. # with their function bodies.
  33. self.suggest_function_names = True
  34. # `self.jit` handles most JIT-related functionality.
  35. self.jit = jit.ModelverseJit()
  36. if self.allow_compiled:
  37. self.jit.compiled_function_lookup = lambda func_name: \
  38. getattr(compiled_functions, func_name, None)
  39. jit_intrinsics.register_intrinsics(self.jit)
  40. # To disable the JIT, uncomment the line below:
  41. #
  42. # self.jit.set_jit_enabled(False)
  43. #
  44. # To disable direct calls in the JIT, uncomment the line below:
  45. #
  46. # self.jit.allow_direct_calls(False)
  47. #
  48. # To disable thunks in the JIT, uncomment the line below:
  49. #
  50. # self.jit.enable_thunks(False)
  51. #
  52. # To make the JIT compile 'input' instructions as calls to
  53. # modelverse_jit.runtime.get_input, uncomment the line below:
  54. #
  55. # self.jit.use_input_function()
  56. #
  57. # To disable source maps in the JIT, uncomment the line below:
  58. #
  59. # self.jit.enable_source_maps(False)
  60. #
  61. # To enable tracing in the JIT (for debugging purposes), uncomment
  62. # the line below:
  63. #
  64. # self.jit.enable_tracing()
  65. #
  66. # To make the JIT print JIT successes and errors to the command-line,
  67. # uncomment the line below:
  68. #
  69. # self.jit.set_jit_success_log()
  70. #
  71. # If you want, you can use a custom logging function:
  72. #
  73. # self.jit.set_jit_success_log(logging_function)
  74. #
  75. # To make the JIT print jitted code to the command-line, uncomment the
  76. # line below:
  77. #
  78. # self.jit.set_jit_code_log()
  79. #
  80. # If you want, you can use a custom logging function:
  81. #
  82. # self.jit.set_jit_code_log(logging_function)
  83. #
  84. self.debug_info = defaultdict(list)
  85. def execute_yields(self, taskname, operation, params, reply):
  86. self.taskname = taskname
  87. if taskname not in self.request_handlers:
  88. self.request_handlers[taskname] = {}
  89. if operation not in self.request_handlers[taskname]:
  90. # Create the generator for the function to execute
  91. self.request_handlers[taskname][operation] = RequestHandler()
  92. handler = self.request_handlers[taskname][operation]
  93. if not handler.is_active():
  94. handler.push_generator(getattr(self, operation)(taskname, *params))
  95. return handler.handle_request(reply)
  96. def execute_rule(self, taskname):
  97. task_root, = yield [("RD", [self.root, taskname])]
  98. if task_root is None:
  99. yield None
  100. else:
  101. task_frame, = yield [("RD", [task_root, "frame"])]
  102. self.inst, phase = yield [("RD", [task_frame, "IP"]),
  103. ("RD", [task_frame, "phase"]),
  104. ]
  105. self.new_debug, self.phase_v, inst_v = \
  106. yield [("RD", [self.inst, "__debug"]),
  107. ("RV", [phase]),
  108. ("RV", [self.inst]),
  109. ]
  110. if self.new_debug is not None:
  111. if self.debug_info[taskname]:
  112. self.debug_info[taskname][-1], = yield [("RV", [self.new_debug])]
  113. if self.phase_v == "finish":
  114. gen = self.helper_init(task_root)
  115. elif self.inst is None:
  116. raise Exception("Instruction pointer could not be found!")
  117. elif isinstance(self.phase_v, string_types):
  118. if self.phase_v == "init" and self.jit.is_jittable_entry_point(self.inst):
  119. #print("%-30s(%s)" % ("COMPILED " + str(self.jit.jitted_entry_points[self.inst]), phase_v))
  120. gen = self.execute_jit(task_root, self.inst, taskname)
  121. elif inst_v is None:
  122. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
  123. else:
  124. #print("%-30s(%s) -- %s" % (inst_v["value"], self.phase_v, taskname))
  125. gen = self.get_inst_phase_generator(inst_v, self.phase_v, task_root)
  126. elif inst_v is None:
  127. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
  128. elif inst_v["value"] == "call":
  129. #print("%-30s(%s)" % ("call", "param"))
  130. gen = self.call_param(task_root)
  131. else:
  132. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
  133. def handle_jit_failed(exception):
  134. # Try again, but this time without the JIT.
  135. gen = self.get_inst_phase_generator(inst_v, self.phase_v, task_root)
  136. yield [("TAIL_CALL", [gen])]
  137. yield [("TRY", [])]
  138. yield [("CATCH", [jit.JitCompilationFailedException, handle_jit_failed])]
  139. yield [("CALL", [gen])]
  140. yield [("END_TRY", [])]
  141. def get_inst_phase_generator(self, inst_v, phase_v, task_root):
  142. """Gets a generator for the given instruction in the given phase,
  143. for the specified task root."""
  144. #print("%-30s(%s) -- %s" % (inst_v["value"], phase_v, taskname))
  145. return getattr(self, "%s_%s" % (inst_v["value"], phase_v))(task_root)
  146. ##########################
  147. ### Process primitives ###
  148. ##########################
  149. def load_primitives(self, taskname):
  150. yield [("CALL_ARGS",
  151. [self.load_primitives_from, (taskname, 'primitives', primitive_functions)])]
  152. yield [("CALL_ARGS",
  153. [self.load_primitives_from, (taskname, 'jit', jit_primitives)])]
  154. def load_primitives_from(self, taskname, source_name, source):
  155. hierarchy, = yield [("RD", [self.root, "__hierarchy"])]
  156. primitives, = yield [("RD", [hierarchy, source_name])]
  157. keys, = yield [("RDK", [primitives])]
  158. function_names = yield [("RV", [f]) for f in keys]
  159. signatures = yield [("RDN", [primitives, f]) for f in keys]
  160. bodies = yield [("RD", [f, "body"]) for f in signatures]
  161. for i in range(len(keys)):
  162. self.jit.register_compiled(
  163. bodies[i],
  164. getattr(source, function_names[i]),
  165. function_names[i])
  166. def jit_compile(self, task_root, inst):
  167. # Try to retrieve the suggested name.
  168. suggested_name = self.jit.get_global_name(inst)
  169. # Have the JIT compile the function.
  170. return self.jit.jit_compile(task_root, inst, suggested_name)
  171. def execute_jit(self, task_root, inst, taskname):
  172. # execute_jit
  173. task_frame, = yield [("RD", [task_root, "frame"])]
  174. symbols, = yield [("RD", [task_frame, "symbols"])]
  175. all_links, = yield [("RO", [symbols])]
  176. containers = yield [("RE", [v]) for v in all_links]
  177. outgoings = yield [("RO", [v]) for v in all_links]
  178. dict_values = yield [("RD", [v[1], "value"]) for v in containers]
  179. formals_1 = yield [("RE", [v[0]]) for v in outgoings]
  180. dict_keys_ref = yield [("RD", [v[1], "name"]) for v in formals_1]
  181. dict_keys = yield [("RV", [v]) for v in dict_keys_ref]
  182. parameters = dict(zip(dict_keys, dict_values))
  183. parameters["root"] = self.root
  184. parameters["task_root"] = task_root
  185. parameters["taskname"] = taskname
  186. parameters["mvk"] = self
  187. # Have the JIT compile the function.
  188. compiled_func, = yield [("CALL_ARGS", [self.jit_compile, (task_root, inst)])]
  189. # Run the compiled function.
  190. results = yield [("CALL_KWARGS", [compiled_func, parameters])]
  191. if results is None:
  192. raise Exception(
  193. "%s: primitive finished without returning a value!" % (self.debug_info[taskname]))
  194. else:
  195. result, = results
  196. # Clean up the current stack, as if a return happened
  197. old_frame, exception_return = yield [
  198. ("RD", [task_frame, "prev"]),
  199. ("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
  200. if self.debug_info[self.taskname]:
  201. self.debug_info[self.taskname].pop()
  202. if exception_return is not None:
  203. # The caller has requested that we throw an exception instead of injecting
  204. # the return value into the caller's frame. Read the comment at
  205. # primitive_functions.EXCEPTION_RETURN_KEY for the rationale behind this design.
  206. yield [("CD", [task_root, "frame", old_frame]),
  207. ("DN", [task_frame])]
  208. raise primitive_functions.InterpretedFunctionFinished(result)
  209. else:
  210. lnk, = yield [("RDE", [old_frame, "returnvalue"])]
  211. _, _, _, _ = yield [("CD", [old_frame, "returnvalue", result]),
  212. ("CD", [task_root, "frame", old_frame]),
  213. ("DE", [lnk]),
  214. ("DN", [task_frame]),
  215. ]
  216. ########################################
  217. ### Execute input and output methods ###
  218. ########################################
  219. def get_output(self, taskname):
  220. task_root, = yield [("RD", [self.root, taskname])]
  221. first_output, = yield [("RD", [task_root, "output"])]
  222. next_output, rv = yield [("RD", [first_output, "next"]),
  223. ("RD", [first_output, "value"]),
  224. ]
  225. if next_output is None:
  226. self.success = False
  227. self.returnvalue = None
  228. else:
  229. rv_value, = yield [("RV", [rv])]
  230. _, _ = yield [("CD", [task_root, "output", next_output]),
  231. ("DN", [first_output]),
  232. ]
  233. self.returnvalue = rv_value
  234. self.success = True
  235. def set_input(self, taskname, value):
  236. task_root, = yield [("RD", [self.root, taskname])]
  237. old_input, link = yield [("RD", [task_root, "last_input"]),
  238. ("RDE", [task_root, "last_input"]),
  239. ]
  240. new_input, = yield [("CN", [])]
  241. _, _ = yield [("CD", [task_root, "last_input", new_input]),
  242. ("CD", [old_input, "next", new_input]),
  243. ]
  244. new_value, = yield [("CNV", [value])]
  245. _, _ = yield [("CD", [old_input, "value", new_value]),
  246. ("DE", [link])
  247. ]
  248. self.returnvalue = {"id": 100, "value": "success"}
  249. #############################################
  250. ### Transformation rules for instructions ###
  251. #############################################
  252. def continue_init(self, task_root):
  253. task_frame, = yield [("RD", [task_root, "frame"])]
  254. inst, = yield [("RD", [task_frame, "IP"])]
  255. while_inst, = yield [("RD", [inst, "while"])]
  256. old_evalstack_link, old_phase_link, evalstack_roots = \
  257. yield [("RDE", [task_frame, "evalstack"]),
  258. ("RDE", [task_frame, "phase"]),
  259. ("RRD", [while_inst, "inst"]),
  260. ]
  261. if len(evalstack_roots) == 1:
  262. evalstack_root = evalstack_roots[0]
  263. else:
  264. raise Exception("Could not process continue statement!")
  265. prev_evalstack_roots, old_evalstack_phase_link = \
  266. yield [("RRD", [evalstack_root, "prev"]),
  267. ("RDE", [evalstack_root, "phase"]),
  268. ]
  269. if len(prev_evalstack_roots) == 1:
  270. prev_evalstack_root = prev_evalstack_roots[0]
  271. else:
  272. raise Exception("Could not process continue statement!")
  273. new_evalstack_root, new_phase_while, new_phase_inst, prev_evalstack_root_link = \
  274. yield [("CN", []),
  275. ("CNV", ["init"]),
  276. ("CNV", ["finish"]),
  277. ("RDE", [prev_evalstack_root, "prev"]),
  278. ]
  279. _, _, _, _, _, _, _, _ = \
  280. yield [("CD", [task_frame, "evalstack", new_evalstack_root]),
  281. ("CD", [new_evalstack_root, "prev", evalstack_root]),
  282. ("CD", [task_frame, "phase", new_phase_inst]),
  283. ("CD", [evalstack_root, "phase", new_phase_while]),
  284. ("DE", [old_evalstack_link]),
  285. ("DE", [prev_evalstack_root_link]),
  286. ("DE", [old_phase_link]),
  287. ("DE", [old_evalstack_phase_link]),
  288. ]
  289. def break_init(self, task_root):
  290. task_frame, = yield [("RD", [task_root, "frame"])]
  291. inst, = yield [("RD", [task_frame, "IP"])]
  292. while_inst, = yield [("RD", [inst, "while"])]
  293. old_evalstack_link, old_phase_link, evalstack_roots = \
  294. yield [("RDE", [task_frame, "evalstack"]),
  295. ("RDE", [task_frame, "phase"]),
  296. ("RRD", [while_inst, "inst"]),
  297. ]
  298. if len(evalstack_roots) == 1:
  299. evalstack_root = evalstack_roots[0]
  300. else:
  301. raise Exception("Could not process break statement!")
  302. prev_evalstack_roots, old_evalstack_phase_link = \
  303. yield [("RRD", [evalstack_root, "prev"]),
  304. ("RDE", [evalstack_root, "phase"]),
  305. ]
  306. if len(prev_evalstack_roots) == 1:
  307. prev_evalstack_root = prev_evalstack_roots[0]
  308. else:
  309. raise Exception("Could not process break statement!")
  310. new_evalstack_root, new_phase_while, new_phase_inst, prev_evalstack_root_link = \
  311. yield [("CN", []),
  312. ("CNV", ["finish"]),
  313. ("CNV", ["finish"]),
  314. ("RDE", [prev_evalstack_root, "prev"]),
  315. ]
  316. _, _, _, _, _, _, _, _ = \
  317. yield [("CD", [task_frame, "evalstack", new_evalstack_root]),
  318. ("CD", [new_evalstack_root, "prev", evalstack_root]),
  319. ("CD", [task_frame, "phase", new_phase_inst]),
  320. ("CD", [evalstack_root, "phase", new_phase_while]),
  321. ("DE", [old_evalstack_link]),
  322. ("DE", [prev_evalstack_root_link]),
  323. ("DE", [old_phase_link]),
  324. ("DE", [old_evalstack_phase_link]),
  325. ]
  326. def if_init(self, task_root):
  327. task_frame, = yield [("RD", [task_root, "frame"])]
  328. evalstack, evalstack_link = \
  329. yield [("RD", [task_frame, "evalstack"]),
  330. ("RDE", [task_frame, "evalstack"]),
  331. ]
  332. inst, ip_link = yield [("RD", [task_frame, "IP"]),
  333. ("RDE", [task_frame, "IP"]),
  334. ]
  335. cond, = yield [("RD", [inst, "cond"])]
  336. new_evalstack, new_phase = \
  337. yield [("CN", []),
  338. ("CNV", ["cond"]),
  339. ]
  340. _, _, _, _, _, _, _ = \
  341. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  342. ("CD", [new_evalstack, "prev", evalstack]),
  343. ("CD", [task_frame, "IP", cond]),
  344. ("CD", [evalstack, "inst", inst]),
  345. ("CD", [evalstack, "phase", new_phase]),
  346. ("DE", [evalstack_link]),
  347. ("DE", [ip_link]),
  348. ]
  349. def if_cond(self, task_root):
  350. task_frame, = yield [("RD", [task_root, "frame"])]
  351. returnvalue, inst = yield [("RD", [task_frame, "returnvalue"]),
  352. ("RD", [task_frame, "IP"]),
  353. ]
  354. returnvalue_v, = yield [("RV", [returnvalue])]
  355. _else, = yield [("RD", [inst, "else"])]
  356. if returnvalue_v:
  357. phase_link, evalstack, evalstack_link, ip_link, _then, new_evalstack, evalstack_phase, new_phase = \
  358. yield [("RDE", [task_frame, "phase"]),
  359. ("RD", [task_frame, "evalstack"]),
  360. ("RDE", [task_frame, "evalstack"]),
  361. ("RDE", [task_frame, "IP"]),
  362. ("RD", [inst, "then"]),
  363. ("CN", []),
  364. ("CNV", ["finish"]),
  365. ("CNV", ["init"]),
  366. ]
  367. _, _, _, _, _, _, _, _, _ = \
  368. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  369. ("CD", [task_frame, "IP", _then]),
  370. ("CD", [new_evalstack, "prev", evalstack]),
  371. ("CD", [evalstack, "inst", inst]),
  372. ("CD", [evalstack, "phase", evalstack_phase]),
  373. ("CD", [task_frame, "phase", new_phase]),
  374. ("DE", [evalstack_link]),
  375. ("DE", [ip_link]),
  376. ("DE", [phase_link]),
  377. ]
  378. elif _else is None:
  379. phase_link, new_phase = \
  380. yield [("RDE", [task_frame, "phase"]),
  381. ("CNV", ["finish"]),
  382. ]
  383. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  384. ("DE", [phase_link]),
  385. ]
  386. else:
  387. phase_link, evalstack, evalstack_link, ip_link = \
  388. yield [("RDE", [task_frame, "phase"]),
  389. ("RD", [task_frame, "evalstack"]),
  390. ("RDE", [task_frame, "evalstack"]),
  391. ("RDE", [task_frame, "IP"]),
  392. ]
  393. new_evalstack, new_phase, evalstack_phase = \
  394. yield [("CN", []),
  395. ("CNV", ["init"]),
  396. ("CNV", ["finish"]),
  397. ]
  398. _, _, _, _, _, _, _, _, _ = \
  399. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  400. ("CD", [task_frame, "IP", _else]),
  401. ("CD", [new_evalstack, "prev", evalstack]),
  402. ("CD", [evalstack, "inst", inst]),
  403. ("CD", [evalstack, "phase", evalstack_phase]),
  404. ("CD", [task_frame, "phase", new_phase]),
  405. ("DE", [evalstack_link]),
  406. ("DE", [ip_link]),
  407. ("DE", [phase_link]),
  408. ]
  409. def while_init(self, task_root):
  410. task_frame, = yield [("RD", [task_root, "frame"])]
  411. evalstack, evalstack_link, ip_link, inst = \
  412. yield [("RD", [task_frame, "evalstack"]),
  413. ("RDE", [task_frame, "evalstack"]),
  414. ("RDE", [task_frame, "IP"]),
  415. ("RD", [task_frame, "IP"]),
  416. ]
  417. cond, new_evalstack, new_phase = \
  418. yield [("RD", [inst, "cond"]),
  419. ("CN", []),
  420. ("CNV", ["cond"]),
  421. ]
  422. _, _, _, _, _, _, _ = \
  423. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  424. ("CD", [new_evalstack, "prev", evalstack]),
  425. ("CD", [task_frame, "IP", cond]),
  426. ("CD", [evalstack, "phase", new_phase]),
  427. ("CD", [evalstack, "inst", inst]),
  428. ("DE", [evalstack_link]),
  429. ("DE", [ip_link]),
  430. ]
  431. def while_cond(self, task_root):
  432. task_frame, = yield [("RD", [task_root, "frame"])]
  433. returnvalue, = yield [("RD", [task_frame, "returnvalue"])]
  434. returnvalue_v, = yield [("RV", [returnvalue])]
  435. if returnvalue_v:
  436. phase_link, evalstack, evalstack_link, ip_link, inst = \
  437. yield [("RDE", [task_frame, "phase"]),
  438. ("RD", [task_frame, "evalstack"]),
  439. ("RDE", [task_frame, "evalstack"]),
  440. ("RDE", [task_frame, "IP"]),
  441. ("RD", [task_frame, "IP"]),
  442. ]
  443. body, = yield [("RD", [inst, "body"])]
  444. new_evalstack, new_phase, evalstack_phase = \
  445. yield [("CN", []),
  446. ("CNV", ["init"]),
  447. ("CNV", ["init"]),
  448. ]
  449. _, _, _, _, _, _, _, _, _ = \
  450. yield [("CD", [task_frame, "IP", body]),
  451. ("CD", [task_frame, "phase", new_phase]),
  452. ("CD", [task_frame, "evalstack", new_evalstack]),
  453. ("CD", [new_evalstack, "prev", evalstack]),
  454. ("CD", [evalstack, "inst", inst]),
  455. ("CD", [evalstack, "phase", evalstack_phase]),
  456. ("DE", [evalstack_link]),
  457. ("DE", [ip_link]),
  458. ("DE", [phase_link]),
  459. ]
  460. else:
  461. phase_link, new_phase = \
  462. yield [("RDE", [task_frame, "phase"]),
  463. ("CNV", ["finish"]),
  464. ]
  465. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  466. ("DE", [phase_link])
  467. ]
  468. def access_init(self, task_root):
  469. task_frame, = yield [("RD", [task_root, "frame"])]
  470. evalstack, evalstack_link, inst, ip_link = \
  471. yield [("RD", [task_frame, "evalstack"]),
  472. ("RDE", [task_frame, "evalstack"]),
  473. ("RD", [task_frame, "IP"]),
  474. ("RDE", [task_frame, "IP"]),
  475. ]
  476. var, new_evalstack, new_phase = \
  477. yield [("RD", [inst, "var"]),
  478. ("CN", []),
  479. ("CNV", ["eval"]),
  480. ]
  481. _, _, _, _, _, _, _ = \
  482. yield [("CD", [task_frame, "IP", var]),
  483. ("CD", [task_frame, "evalstack", new_evalstack]),
  484. ("CD", [new_evalstack, "prev", evalstack]),
  485. ("CD", [evalstack, "inst", inst]),
  486. ("CD", [evalstack, "phase", new_phase]),
  487. ("DE", [evalstack_link]),
  488. ("DE", [ip_link]),
  489. ]
  490. def access_eval(self, task_root):
  491. task_frame, = yield [("RD", [task_root, "frame"])]
  492. phase_link, returnvalue_link, returnvalue = \
  493. yield [("RDE", [task_frame, "phase"]),
  494. ("RDE", [task_frame, "returnvalue"]),
  495. ("RD", [task_frame, "returnvalue"]),
  496. ]
  497. value, new_phase = yield [("RD", [returnvalue, "value"]),
  498. ("CNV", ["finish"]),
  499. ]
  500. _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  501. ("CD", [task_frame, "returnvalue", value]),
  502. ("DE", [phase_link]),
  503. ("DE", [returnvalue_link]),
  504. ]
  505. def resolve_init(self, task_root):
  506. task_frame, = yield [("RD", [task_root, "frame"])]
  507. symbols, evalstack, evalstack_link, ip_link, inst = \
  508. yield [("RD", [task_frame, "symbols"]),
  509. ("RD", [task_frame, "evalstack"]),
  510. ("RDE", [task_frame, "evalstack"]),
  511. ("RDE", [task_frame, "IP"]),
  512. ("RD", [task_frame, "IP"]),
  513. ]
  514. var, = yield [("RD", [inst, "var"])]
  515. variable, = yield [("RDN", [symbols, var])]
  516. if variable is None:
  517. phase_link, returnvalue_link, _globals, var_name = \
  518. yield [("RDE", [task_frame, "phase"]),
  519. ("RDE", [task_frame, "returnvalue"]),
  520. ("RD", [task_root, "globals"]),
  521. ("RV", [var]),
  522. ]
  523. variable, new_phase = \
  524. yield [("RD", [_globals, var_name]),
  525. ("CNV", ["finish"]),
  526. ]
  527. if variable is None:
  528. raise Exception(jit_runtime.GLOBAL_NOT_FOUND_MESSAGE_FORMAT % var_name)
  529. # Resolved a global, so this is a string
  530. # Potentially, this might even be a function that we have precompiled already!
  531. # So check whether this is the case or not
  532. if self.allow_compiled:
  533. compiled_function = getattr(compiled_functions, var_name, None)
  534. if compiled_function is not None:
  535. # We have a compiled function ready!
  536. # Now we have to bind the ID to the compiled functions
  537. # For this, we read out the body of the resolved data
  538. compiler_val, = yield [("RD", [variable, "value"])]
  539. compiler_body, = yield [("RD", [compiler_val, "body"])]
  540. self.jit.register_compiled(compiler_body, compiled_function, var_name)
  541. # If we're dealing with a function, then we might want to figure out what its body id
  542. # is now so we can suggest a name to the JIT later.
  543. if self.suggest_function_names and self.jit.get_global_body_id(var_name) is None:
  544. compiler_val, = yield [("RD", [variable, "value"])]
  545. if compiler_val is not None:
  546. compiler_body, = yield [("RD", [compiler_val, "body"])]
  547. if compiler_body is not None:
  548. self.jit.register_global(compiler_body, var_name)
  549. else:
  550. phase_link, returnvalue_link, new_phase = \
  551. yield [("RDE", [task_frame, "phase"]),
  552. ("RDE", [task_frame, "returnvalue"]),
  553. ("CNV", ["finish"]),
  554. ]
  555. _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  556. ("CD", [task_frame, "returnvalue", variable]),
  557. ("DE", [phase_link]),
  558. ("DE", [returnvalue_link]),
  559. ]
  560. def assign_init(self, task_root):
  561. task_frame, = yield [("RD", [task_root, "frame"])]
  562. evalstack, evalstack_link, ip_link, inst = \
  563. yield [("RD", [task_frame, "evalstack"]),
  564. ("RDE", [task_frame, "evalstack"]),
  565. ("RDE", [task_frame, "IP"]),
  566. ("RD", [task_frame, "IP"]),
  567. ]
  568. var, new_evalstack, new_phase = \
  569. yield [("RD", [inst, "var"]),
  570. ("CN", []),
  571. ("CNV", ["value"]),
  572. ]
  573. _, _, _, _, _, _, _ = \
  574. yield [("CD", [task_frame, "IP", var]),
  575. ("CD", [task_frame, "evalstack", new_evalstack]),
  576. ("CD", [new_evalstack, "prev", evalstack]),
  577. ("CD", [evalstack, "inst", inst]),
  578. ("CD", [evalstack, "phase", new_phase]),
  579. ("DE", [evalstack_link]),
  580. ("DE", [ip_link]),
  581. ]
  582. def assign_value(self, task_root):
  583. task_frame, = yield [("RD", [task_root, "frame"])]
  584. phase_link, evalstack, returnvalue, evalstack_link, ip_link, inst = \
  585. yield [("RDE", [task_frame, "phase"]),
  586. ("RD", [task_frame, "evalstack"]),
  587. ("RD", [task_frame, "returnvalue"]),
  588. ("RDE", [task_frame, "evalstack"]),
  589. ("RDE", [task_frame, "IP"]),
  590. ("RD", [task_frame, "IP"]),
  591. ]
  592. value, new_evalstack, new_phase, evalstack_phase = \
  593. yield [("RD", [inst, "value"]),
  594. ("CN", []),
  595. ("CNV", ["init"]),
  596. ("CNV", ["assign"]),
  597. ]
  598. _, _, _, _, _, _, _, _, _, _ = \
  599. yield [("CD", [task_frame, "variable", returnvalue]),
  600. ("CD", [task_frame, "phase", new_phase]),
  601. ("CD", [task_frame, "evalstack", new_evalstack]),
  602. ("CD", [new_evalstack, "prev", evalstack]),
  603. ("CD", [evalstack, "inst", inst]),
  604. ("CD", [evalstack, "phase", evalstack_phase]),
  605. ("CD", [task_frame, "IP", value]),
  606. ("DE", [evalstack_link]),
  607. ("DE", [phase_link]),
  608. ("DE", [ip_link]),
  609. ]
  610. def assign_assign(self, task_root):
  611. task_frame, = yield [("RD", [task_root, "frame"])]
  612. phase_link, returnvalue, variable_link, variable = \
  613. yield [("RDE", [task_frame, "phase"]),
  614. ("RD", [task_frame, "returnvalue"]),
  615. ("RDE", [task_frame, "variable"]),
  616. ("RD", [task_frame, "variable"]),
  617. ]
  618. value_link, new_phase = \
  619. yield [("RDE", [variable, "value"]),
  620. ("CNV", ["finish"]),
  621. ]
  622. _, _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  623. ("CD", [variable, "value", returnvalue]),
  624. ("DE", [variable_link]),
  625. ("DE", [value_link]),
  626. ("DE", [phase_link]),
  627. ]
  628. def return_init(self, task_root):
  629. task_frame, = yield [("RD", [task_root, "frame"])]
  630. inst, = yield [("RD", [task_frame, "IP"])]
  631. value, = yield [("RD", [inst, "value"])]
  632. if value is None:
  633. prev_frame, = yield [("RD", [task_frame, "prev"])]
  634. # If the callee's frame is marked with the '__exception_return' key, then
  635. # we need to throw an exception instead of just finishing here. This design
  636. # gives us O(1) state reads per jit-interpreter transition.
  637. exception_return, = yield [("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
  638. if prev_frame is None:
  639. _, = yield [("DN", [task_root])]
  640. del self.debug_info[self.taskname]
  641. else:
  642. if self.debug_info[self.taskname]:
  643. self.debug_info[self.taskname].pop()
  644. _, _ = yield [("CD", [task_root, "frame", prev_frame]),
  645. ("DN", [task_frame]),
  646. ]
  647. if exception_return is not None:
  648. raise primitive_functions.InterpretedFunctionFinished(None)
  649. else:
  650. evalstack, evalstack_link, ip_link, new_evalstack, evalstack_phase = \
  651. yield [("RD", [task_frame, "evalstack"]),
  652. ("RDE", [task_frame, "evalstack"]),
  653. ("RDE", [task_frame, "IP"]),
  654. ("CN", []),
  655. ("CNV", ["eval"]),
  656. ]
  657. _, _, _, _, _, _, _ = \
  658. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  659. ("CD", [new_evalstack, "prev", evalstack]),
  660. ("CD", [evalstack, "inst", inst]),
  661. ("CD", [evalstack, "phase", evalstack_phase]),
  662. ("CD", [task_frame, "IP", value]),
  663. ("DE", [evalstack_link]),
  664. ("DE", [ip_link]),
  665. ]
  666. def return_eval(self, task_root):
  667. if self.debug_info[self.taskname]:
  668. self.debug_info[self.taskname].pop()
  669. task_frame, = yield [("RD", [task_root, "frame"])]
  670. prev_frame, = yield [("RD", [task_frame, "prev"])]
  671. if prev_frame is None:
  672. _, = yield [("DN", [task_root])]
  673. del self.debug_info[self.taskname]
  674. exception_return, returnvalue = yield [
  675. ("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY]),
  676. ("RD", [task_frame, "returnvalue"])]
  677. # If the callee's frame is marked with the '__exception_return' key, then
  678. # we need to throw an exception instead of just finishing here. This design
  679. # gives us O(1) state reads per jit-interpreter transition.
  680. if exception_return is not None:
  681. yield [
  682. ("CD", [task_root, "frame", prev_frame]),
  683. ("DN", [task_frame])]
  684. raise primitive_functions.InterpretedFunctionFinished(returnvalue)
  685. else:
  686. old_returnvalue_link, = yield [("RDE", [prev_frame, "returnvalue"])]
  687. yield [
  688. ("CD", [task_root, "frame", prev_frame]),
  689. ("CD", [prev_frame, "returnvalue", returnvalue]),
  690. ("DE", [old_returnvalue_link]),
  691. ("DN", [task_frame])]
  692. def constant_init(self, task_root):
  693. task_frame, = yield [("RD", [task_root, "frame"])]
  694. phase_link, returnvalue_link, inst = \
  695. yield [("RDE", [task_frame, "phase"]),
  696. ("RDE", [task_frame, "returnvalue"]),
  697. ("RD", [task_frame, "IP"]),
  698. ]
  699. node, new_phase = yield [("RD", [inst, "node"]),
  700. ("CNV", ["finish"]),
  701. ]
  702. _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  703. ("CD", [task_frame, "returnvalue", node]),
  704. ("DE", [returnvalue_link]),
  705. ("DE", [phase_link]),
  706. ]
  707. def helper_init(self, task_root):
  708. task_frame, = yield [("RD", [task_root, "frame"])]
  709. inst, = yield [("RD", [task_frame, "IP"])]
  710. next, = yield [("RD", [inst, "next"])]
  711. if next is None:
  712. ip_link, phase_link, evalstack_top = \
  713. yield [("RDE", [task_frame, "IP"]),
  714. ("RDE", [task_frame, "phase"]),
  715. ("RD", [task_frame, "evalstack"]),
  716. ]
  717. evalstack, = yield [("RD", [evalstack_top, "prev"])]
  718. evalstack_inst, evalstack_phase, evalstack_inst_link, evalstack_phase_link = \
  719. yield [("RD", [evalstack, "inst"]),
  720. ("RD", [evalstack, "phase"]),
  721. ("RDE", [evalstack, "inst"]),
  722. ("RDE", [evalstack, "phase"]),
  723. ]
  724. _, _, _, _, _, _, _, _ = \
  725. yield [("CD", [task_frame, "evalstack", evalstack]),
  726. ("CD", [task_frame, "IP", evalstack_inst]),
  727. ("CD", [task_frame, "phase", evalstack_phase]),
  728. ("DE", [ip_link]),
  729. ("DE", [phase_link]),
  730. ("DE", [evalstack_inst_link]),
  731. ("DE", [evalstack_phase_link]),
  732. ("DN", [evalstack_top]),
  733. ]
  734. else:
  735. ip_link, phase_link, new_phase = \
  736. yield [("RDE", [task_frame, "IP"]),
  737. ("RDE", [task_frame, "phase"]),
  738. ("CNV", ["init"]),
  739. ]
  740. _, _, _, _ = yield [("CD", [task_frame, "IP", next]),
  741. ("CD", [task_frame, "phase", new_phase]),
  742. ("DE", [ip_link]),
  743. ("DE", [phase_link]),
  744. ]
  745. def call_init(self, task_root):
  746. task_frame, = yield [("RD", [task_root, "frame"])]
  747. symbols, evalstack, evalstack_link, ip_link, inst = \
  748. yield [("RD", [task_frame, "symbols"]),
  749. ("RD", [task_frame, "evalstack"]),
  750. ("RDE", [task_frame, "evalstack"]),
  751. ("RDE", [task_frame, "IP"]),
  752. ("RD", [task_frame, "IP"]),
  753. ]
  754. func, params = yield [("RD", [inst, "func"]),
  755. ("RD", [inst, "params"]),
  756. ]
  757. if params is None:
  758. new_evalstack, evalstack_phase = \
  759. yield [("CN", []),
  760. ("CNV", ["call"]),
  761. ]
  762. _, _, _, _, _, _, _ = \
  763. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  764. ("CD", [new_evalstack, "prev", evalstack]),
  765. ("CD", [evalstack, "inst", inst]),
  766. ("CD", [evalstack, "phase", evalstack_phase]),
  767. ("CD", [task_frame, "IP", func]),
  768. ("DE", [evalstack_link]),
  769. ("DE", [ip_link]),
  770. ]
  771. else:
  772. new_evalstack,= yield [("CN", [])]
  773. _, _, _, _, _, _, _ = \
  774. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  775. ("CD", [new_evalstack, "prev", evalstack]),
  776. ("CD", [evalstack, "inst", inst]),
  777. ("CD", [evalstack, "phase", params]),
  778. ("CD", [task_frame, "IP", func]),
  779. ("DE", [evalstack_link]),
  780. ("DE", [ip_link]),
  781. ]
  782. def call_call(self, task_root):
  783. self.debug_info[self.taskname].append("None")
  784. task_frame, = yield [("RD", [task_root, "frame"])]
  785. inst, = yield [("RD", [task_frame, "IP"])]
  786. param, = yield [("RD", [inst, "last_param"])]
  787. if param is None:
  788. returnvalue, = yield [("RD", [task_frame, "returnvalue"])]
  789. body, = yield [("RD", [returnvalue, "body"])]
  790. self.jit.mark_entry_point(body)
  791. phase_link, frame_link, prev_phase, new_phase, new_frame, new_evalstack, new_symbols, new_returnvalue = \
  792. yield [("RDE", [task_frame, "phase"]),
  793. ("RDE", [task_root, "frame"]),
  794. ("CNV", ["finish"]),
  795. ("CNV", ["init"]),
  796. ("CN", []),
  797. ("CN", []),
  798. ("CN", []),
  799. ("CN", []),
  800. ]
  801. _, _, _, _, _, _, _, _, _, _, _ = \
  802. yield [("CD", [task_root, "frame", new_frame]),
  803. ("CD", [new_frame, "evalstack", new_evalstack]),
  804. ("CD", [new_frame, "symbols", new_symbols]),
  805. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  806. ("CD", [new_frame, "caller", inst]),
  807. ("CD", [new_frame, "phase", new_phase]),
  808. ("CD", [new_frame, "IP", body]),
  809. ("CD", [new_frame, "prev", task_frame]),
  810. ("CD", [task_frame, "phase", prev_phase]),
  811. ("DE", [phase_link]),
  812. ("DE", [frame_link]),
  813. ]
  814. else:
  815. newer_frames, invoking_frames = \
  816. yield [("RRD", [task_frame, "prev"]),
  817. ("RRD", [inst, "caller"]),
  818. ]
  819. new_frame = self.find_overlapping(newer_frames, invoking_frames)
  820. phase_link, frame_link, new_symbols, new_IP = \
  821. yield [("RDE", [task_frame, "phase"]),
  822. ("RDE", [task_root, "frame"]),
  823. ("RD", [new_frame, "symbols"]),
  824. ("RD", [new_frame, "IP"]),
  825. ]
  826. signature, = yield [("RRD", [new_IP, "body"])]
  827. signature = signature[0]
  828. sig_params, last_param = \
  829. yield [("RD", [signature, "params"]),
  830. ("RD", [inst, "last_param"]),
  831. ]
  832. body, = yield [("RD", [new_IP, "body"])]
  833. self.jit.mark_entry_point(body)
  834. name, = yield [("RD", [last_param, "name"])]
  835. name_value, = yield [("RV", [name])]
  836. returnvalue, formal_parameter, new_phase, variable = \
  837. yield [("RD", [task_frame, "returnvalue"]),
  838. ("RD", [sig_params, name_value]),
  839. ("CNV", ["finish"]),
  840. ("CN", []),
  841. ]
  842. _, _, _, t1 = yield [("CD", [task_root, "frame", new_frame]),
  843. ("CD", [task_frame, "phase", new_phase]),
  844. ("CD", [variable, "value", returnvalue]),
  845. ("CE", [new_symbols, variable]),
  846. ]
  847. _, _, _ = yield [("CE", [t1, formal_parameter]),
  848. ("DE", [frame_link]),
  849. ("DE", [phase_link]),
  850. ]
  851. def find_overlapping(self, a, b):
  852. newer_frames = set(a)
  853. invoking_frames = set(b)
  854. matches = list(newer_frames.intersection(invoking_frames))
  855. if len(matches) == 1:
  856. return matches[0]
  857. elif len(matches) > 1:
  858. raise Exception("Error: multiple overlapping elements")
  859. else:
  860. raise Exception("Error: could not find any overlap")
  861. def call_param(self, task_root):
  862. task_frame, = yield [("RD", [task_root, "frame"])]
  863. inst, phase = yield [("RD", [task_frame, "IP"]),
  864. ("RD", [task_frame, "phase"]),
  865. ]
  866. params, last_param = \
  867. yield [("RD", [inst, "params"]),
  868. ("RD", [inst, "last_param"]),
  869. ]
  870. next_param, = yield [("RD", [params, "next_param"])]
  871. if params == phase:
  872. phase_link, ip_link, returnvalue, param_value, evalstack, evalstack_link = \
  873. yield [("RDE", [task_frame, "phase"]),
  874. ("RDE", [task_frame, "IP"]),
  875. ("RD", [task_frame, "returnvalue"]),
  876. ("RD", [params, "value"]),
  877. ("RD", [task_frame, "evalstack"]),
  878. ("RDE", [task_frame, "evalstack"]),
  879. ]
  880. body, = yield [("RD", [returnvalue, "body"])]
  881. new_frame, prev_evalstack, new_phase, prev_phase, new_evalstack, new_symbols, new_returnvalue = \
  882. yield [("CN", []),
  883. ("CN", []),
  884. ("CNV", ["init"]),
  885. ("CNV", ["init"]),
  886. ("CN", []),
  887. ("CN", []),
  888. ("CN", []),
  889. ]
  890. _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = \
  891. yield [("CD", [new_frame, "evalstack", new_evalstack]),
  892. ("CD", [new_frame, "symbols", new_symbols]),
  893. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  894. ("CD", [new_frame, "caller", inst]),
  895. ("CD", [new_frame, "phase", new_phase]),
  896. ("CD", [new_frame, "IP", body]),
  897. ("CD", [new_frame, "prev", task_frame]),
  898. ("CD", [task_frame, "phase", prev_phase]),
  899. ("CD", [task_frame, "IP", param_value]),
  900. ("CD", [prev_evalstack, "prev", evalstack]),
  901. ("CD", [evalstack, "inst", inst]),
  902. ("CD", [task_frame, "evalstack", prev_evalstack]),
  903. ("DE", [evalstack_link]),
  904. ("DE", [ip_link]),
  905. ("DE", [phase_link]),
  906. ]
  907. if next_param is not None:
  908. _ = yield [("CD", [evalstack, "phase", next_param])]
  909. else:
  910. evalstack_phase, = \
  911. yield [("CNV", ["call"])]
  912. _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
  913. else:
  914. frame_link, phase_link, newer_frames, invoking_frames = \
  915. yield [("RDE", [task_root, "frame"]),
  916. ("RDE", [task_frame, "phase"]),
  917. ("RRD", [task_frame, "prev"]),
  918. ("RRD", [inst, "caller"]),
  919. ]
  920. new_frame = self.find_overlapping(newer_frames, invoking_frames)
  921. ip_link, evalstack, evalstack_link, new_symbols, new_IP = \
  922. yield [("RDE", [task_frame, "IP"]),
  923. ("RD", [task_frame, "evalstack"]),
  924. ("RDE", [task_frame, "evalstack"]),
  925. ("RD", [new_frame, "symbols"]),
  926. ("RD", [new_frame, "IP"]),
  927. ]
  928. signature, = yield [("RRD", [new_IP, "body"])]
  929. signature = signature[0]
  930. sig_params, = yield [("RD", [signature, "params"])]
  931. if last_param == phase:
  932. prev_param, = \
  933. yield [("RRD", [last_param, "next_param"])]
  934. prev_param = prev_param[0]
  935. name, = yield [("RD", [prev_param, "name"])]
  936. name_value, = \
  937. yield [("RV", [name])]
  938. evalstack_phase, = \
  939. yield [("CNV", ["call"])]
  940. _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
  941. formal_parameter, param_value = \
  942. yield [("RD", [sig_params, name_value]),
  943. ("RD", [last_param, "value"]),
  944. ]
  945. else:
  946. param_b, = yield [("RD", [task_frame, "phase"])]
  947. param_c, param_a = \
  948. yield [("RD", [param_b, "next_param"]),
  949. ("RRD", [param_b, "next_param"]),
  950. ]
  951. param_a = param_a[0]
  952. name, param_value = \
  953. yield [("RD", [param_a, "name"]),
  954. ("RD", [param_b, "value"]),
  955. ]
  956. name_value, = \
  957. yield [("RV", [name])]
  958. formal_parameter, _ = \
  959. yield [("RD", [sig_params, name_value]),
  960. ("CD", [evalstack, "phase", param_c]),
  961. ]
  962. new_phase, new_evalstack, variable, returnvalue = \
  963. yield [("CNV", ["init"]),
  964. ("CN", []),
  965. ("CN", []),
  966. ("RD", [task_frame, "returnvalue"]),
  967. ]
  968. _, _, _, _, _, _ = \
  969. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  970. ("CD", [new_evalstack, "prev", evalstack]),
  971. ("CD", [evalstack, "inst", inst]),
  972. ("CD", [task_frame, "phase", new_phase]),
  973. ("CD", [task_frame, "IP", param_value]),
  974. ("CD", [variable, "value", returnvalue]),
  975. ]
  976. t1, = yield [("CE", [new_symbols, variable])]
  977. _, _, _, _ = \
  978. yield [("CE", [t1, formal_parameter]),
  979. ("DE", [phase_link]),
  980. ("DE", [ip_link]),
  981. ("DE", [evalstack_link]),
  982. ]
  983. def input_init(self, task_root):
  984. task_frame, = yield [("RD", [task_root, "frame"])]
  985. returnvalue_link, _input = \
  986. yield [("RDE", [task_frame, "returnvalue"]),
  987. ("RD", [task_root, "input"]),
  988. ]
  989. value, next, phase_link = \
  990. yield [("RD", [_input, "value"]),
  991. ("RD", [_input, "next"]),
  992. ("RDE", [task_frame, "phase"]),
  993. ]
  994. if value is not None:
  995. v = yield [("RV", [value])]
  996. _, _, finish = \
  997. yield [("CD", [task_frame, "returnvalue", value]),
  998. ("CD", [task_root, "input", next]),
  999. ("CNV", ["finish"]),
  1000. ]
  1001. _, _, _, _ = \
  1002. yield [("CD", [task_frame, "phase", finish]),
  1003. ("DN", [_input]),
  1004. ("DE", [returnvalue_link]),
  1005. ("DE", [phase_link]),
  1006. ]
  1007. self.input_value = value
  1008. else:
  1009. # No input yet, so just wait and don't advance IP or phase
  1010. self.input_value = None
  1011. self.success = False
  1012. def output_init(self, task_root):
  1013. task_frame, = yield [("RD", [task_root, "frame"])]
  1014. evalstack, evalstack_link, ip_link, inst = \
  1015. yield [("RD", [task_frame, "evalstack"]),
  1016. ("RDE", [task_frame, "evalstack"]),
  1017. ("RDE", [task_frame, "IP"]),
  1018. ("RD", [task_frame, "IP"]),
  1019. ]
  1020. value, new_evalstack, evalstack_phase = \
  1021. yield [("RD", [inst, "value"]),
  1022. ("CN", []),
  1023. ("CNV", ["output"]),
  1024. ]
  1025. _, _, _, _, _, _, _ = \
  1026. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  1027. ("CD", [new_evalstack, "prev", evalstack]),
  1028. ("CD", [evalstack, "inst", inst]),
  1029. ("CD", [evalstack, "phase", evalstack_phase]),
  1030. ("CD", [task_frame, "IP", value]),
  1031. ("DE", [evalstack_link]),
  1032. ("DE", [ip_link]),
  1033. ]
  1034. def output_output(self, task_root):
  1035. task_frame, = yield [("RD", [task_root, "frame"])]
  1036. returnvalue_link, returnvalue, last_output, phase_link, last_output_link, new_last_output, finish = \
  1037. yield [("RDE", [task_frame, "returnvalue"]),
  1038. ("RD", [task_frame, "returnvalue"]),
  1039. ("RD", [task_root, "last_output"]),
  1040. ("RDE", [task_frame, "phase"]),
  1041. ("RDE", [task_root, "last_output"]),
  1042. ("CN", []),
  1043. ("CNV", ["finish"]),
  1044. ]
  1045. _, _, _, _, _, _ = \
  1046. yield [("CD", [last_output, "value", returnvalue]),
  1047. ("CD", [last_output, "next", new_last_output]),
  1048. ("CD", [task_root, "last_output", new_last_output]),
  1049. ("CD", [task_frame, "phase", finish]),
  1050. ("DE", [last_output_link]),
  1051. ("DE", [phase_link]),
  1052. ]
  1053. def declare_init(self, task_root):
  1054. task_frame, = yield [("RD", [task_root, "frame"])]
  1055. inst, = yield [("RD", [task_frame, "IP"])]
  1056. new_var, symbols, phase_link, empty_node, new_phase = \
  1057. yield [("RD", [inst, "var"]),
  1058. ("RD", [task_frame, "symbols"]),
  1059. ("RDE", [task_frame, "phase"]),
  1060. ("CN", []),
  1061. ("CNV", ["finish"]),
  1062. ]
  1063. exists, = yield [("RDN", [symbols, new_var])]
  1064. if exists is None:
  1065. new_edge, = yield [("CE", [symbols, empty_node])]
  1066. _ = yield [("CE", [new_edge, new_var])]
  1067. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  1068. ("DE", [phase_link]),
  1069. ]
  1070. def global_init(self, task_root):
  1071. task_frame, = yield [("RD", [task_root, "frame"])]
  1072. inst, = yield [("RD", [task_frame, "IP"])]
  1073. new_var, global_symbols, phase_link, empty_node, new_phase = \
  1074. yield [("RD", [inst, "var"]),
  1075. ("RD", [task_root, "globals"]),
  1076. ("RDE", [task_frame, "phase"]),
  1077. ("CN", []),
  1078. ("CNV", ["finish"]),
  1079. ]
  1080. value, = yield [("RV", [new_var])]
  1081. exists, = yield [("RDE", [global_symbols, value])]
  1082. if exists is not None:
  1083. yield [("DE", [exists])]
  1084. yield [("CD", [global_symbols, value, empty_node])]
  1085. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  1086. ("DE", [phase_link])
  1087. ]