main.py 50 KB

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