main.py 50 KB

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