main.py 51 KB

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