main.py 55 KB

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