main.py 59 KB

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