main.py 59 KB

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