main.py 55 KB

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