main.py 49 KB

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