main.py 59 KB

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