primitives.py 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516
  1. # Exception to indicate the result value of the primitive, as a return cannot be used
  2. class PrimitiveFinished(Exception):
  3. def __init__(self, value):
  4. self.result = value
  5. def integer_subtraction(a, b, **remainder):
  6. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  7. result = yield [("CNV", [a_value - b_value])]
  8. raise PrimitiveFinished(result)
  9. def integer_addition(a, b, **remainder):
  10. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  11. result = yield [("CNV", [a_value + b_value])]
  12. raise PrimitiveFinished(result)
  13. def integer_multiplication(a, b, **remainder):
  14. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  15. result = yield [("CNV", [a_value * b_value])]
  16. raise PrimitiveFinished(result)
  17. def integer_division(a, b, **remainder):
  18. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  19. result = yield [("CNV", [int(a_value) / b_value])]
  20. raise PrimitiveFinished(result)
  21. def integer_gt(a, b, **remainder):
  22. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  23. result = yield [("CNV", [a_value > b_value])]
  24. raise PrimitiveFinished(result)
  25. def integer_lt(a, b, **remainder):
  26. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  27. result = yield [("CNV", [a_value < b_value])]
  28. raise PrimitiveFinished(result)
  29. def integer_neg(a, **remainder):
  30. a_value = yield [("RV", [a])]
  31. result = yield [("CNV", [-a_value])]
  32. raise PrimitiveFinished(result)
  33. def bool_and(a, b, **remainder):
  34. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  35. result = yield [("CNV", [a_value and b_value])]
  36. raise PrimitiveFinished(result)
  37. def bool_or(a, b, **remainder):
  38. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  39. result = yield [("CNV", [a_value or b_value])]
  40. raise PrimitiveFinished(result)
  41. def bool_not(a, **remainder):
  42. a_value = yield [("RV", [a])]
  43. result = yield [("CNV", [not a_value])]
  44. raise PrimitiveFinished(result)
  45. def float_subtraction(a, b, **remainder):
  46. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  47. result = yield [("CNV", [a_value - b_value])]
  48. raise PrimitiveFinished(result)
  49. def float_addition(a, b, **remainder):
  50. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  51. result = yield [("CNV", [a_value + b_value])]
  52. raise PrimitiveFinished(result)
  53. def float_multiplication(a, b, **remainder):
  54. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  55. result = yield [("CNV", [a_value * b_value])]
  56. raise PrimitiveFinished(result)
  57. def float_division(a, b, **remainder):
  58. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  59. result = yield [("CNV", [a_value / b_value])]
  60. raise PrimitiveFinished(result)
  61. def float_gt(a, b, **remainder):
  62. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  63. result = yield [("CNV", [a_value > b_value])]
  64. raise PrimitiveFinished(result)
  65. def float_lt(a, b, **remainder):
  66. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  67. result = yield [("CNV", [a_value < b_value])]
  68. raise PrimitiveFinished(result)
  69. def float_neg(a, **remainder):
  70. a_value = yield [("RV", [a])]
  71. result = yield [("CNV", [-a_value])]
  72. raise PrimitiveFinished(result)
  73. def string_join(a, b, **remainder):
  74. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  75. result = yield [("CNV", [str(a_value) + str(b_value)])]
  76. raise PrimitiveFinished(result)
  77. def string_split(a, b, **remainder):
  78. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  79. result = a_value.split(b_value)
  80. elems = yield [("CN", [])] + [("CNV", [v]) for v in result]
  81. new_val = elems[0]
  82. yield [("CD", [new_val, i, v]) for i, v in enumerate(elems[1:])]
  83. raise PrimitiveFinished(new_val)
  84. def string_get(a, b, **remainder):
  85. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  86. result = yield [("CNV", [a_value[b_value]])]
  87. raise PrimitiveFinished(result)
  88. def string_len(a, **remainder):
  89. a_value = yield [("RV", [a])]
  90. result = yield [("CNV", [len(a_value)])]
  91. raise PrimitiveFinished(result)
  92. def value_eq(a, b, **remainder):
  93. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  94. result = yield [("CNV", [a_value == b_value])]
  95. raise PrimitiveFinished(result)
  96. def value_neq(a, b, **remainder):
  97. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  98. result = yield [("CNV", [a_value != b_value])]
  99. raise PrimitiveFinished(result)
  100. def element_eq(a, b, **remainder):
  101. result = yield [("CNV", [a == b])]
  102. raise PrimitiveFinished(result)
  103. def element_neq(a, b, **remainder):
  104. result = yield [("CNV", [a != b])]
  105. raise PrimitiveFinished(result)
  106. def cast_a2s(a, **remainder):
  107. a_value = yield [("RV", [a])]
  108. result = yield [("CNV", [str(a_value["value"])])]
  109. raise PrimitiveFinished(result)
  110. def cast_i2f(a, **remainder):
  111. a_value = yield [("RV", [a])]
  112. result = yield [("CNV", [float(a_value)])]
  113. raise PrimitiveFinished(result)
  114. def cast_i2s(a, **remainder):
  115. a_value = yield [("RV", [a])]
  116. result = yield [("CNV", [str(a_value)])]
  117. raise PrimitiveFinished(result)
  118. def cast_i2b(a, **remainder):
  119. a_value = yield [("RV", [a])]
  120. result = yield [("CNV", [bool(a_value)])]
  121. raise PrimitiveFinished(result)
  122. def cast_f2i(a, **remainder):
  123. a_value = yield [("RV", [a])]
  124. result = yield [("CNV", [int(a_value)])]
  125. raise PrimitiveFinished(result)
  126. def cast_f2s(a, **remainder):
  127. a_value = yield [("RV", [a])]
  128. result = yield [("CNV", [str(a_value)])]
  129. raise PrimitiveFinished(result)
  130. def cast_f2b(a, **remainder):
  131. a_value = yield [("RV", [a])]
  132. result = yield [("CNV", [bool(a_value)])]
  133. raise PrimitiveFinished(result)
  134. def cast_s2i(a, **remainder):
  135. a_value = yield [("RV", [a])]
  136. result = yield [("CNV", [int(a_value)])]
  137. raise PrimitiveFinished(result)
  138. def cast_s2f(a, **remainder):
  139. a_value = yield [("RV", [a])]
  140. result = yield [("CNV", [float(a_value)])]
  141. raise PrimitiveFinished(result)
  142. def cast_s2b(a, **remainder):
  143. a_value = yield [("RV", [a])]
  144. result = yield [("CNV", [bool(a_value)])]
  145. raise PrimitiveFinished(result)
  146. def cast_b2i(a, **remainder):
  147. a_value = yield [("RV", [a])]
  148. result = yield [("CNV", [int(a_value)])]
  149. raise PrimitiveFinished(result)
  150. def cast_b2f(a, **remainder):
  151. a_value = yield [("RV", [a])]
  152. result = yield [("CNV", [float(a_value)])]
  153. raise PrimitiveFinished(result)
  154. def cast_b2s(a, **remainder):
  155. a_value = yield [("RV", [a])]
  156. result = yield [("CNV", [str(a_value)])]
  157. raise PrimitiveFinished(result)
  158. def cast_e2s(a, **remainder):
  159. a_value = yield [("RV", [a])]
  160. result = yield [("CNV", ["{ID: %s, value: %s}" % (a, a_value)])]
  161. raise PrimitiveFinished(result)
  162. def cast_v2s(a, **remainder):
  163. a_value = yield [("RV", [a])]
  164. if isinstance(a_value, (str, unicode)):
  165. # String should be encoded to distinguish between 3 and "3"
  166. a_value = '"%s"' % a_value
  167. elif isinstance(a_value, dict):
  168. # Action or type
  169. a_value = a_value["value"]
  170. result = yield [("CNV", ["%s" % (a_value)])]
  171. raise PrimitiveFinished(result)
  172. def cast_id2s(a, **remainder):
  173. result = yield [("CNV", ["%s" % (a)])]
  174. raise PrimitiveFinished(result)
  175. def list_append(a, b, **remainder):
  176. a_outgoing = yield [("RO", [a])]
  177. _ = yield [("CD", [a, len(a_outgoing), b])]
  178. raise PrimitiveFinished(a)
  179. def list_insert(a, b, c, **remainder):
  180. a_outgoing, c_value = yield [("RO", [a]), ("RV", [c])]
  181. links = yield [("RD", [a, i]) for i in range(c_value, len(a_outgoing))] + \
  182. [("RDE", [a, i]) for i in range(c_value, len(a_outgoing))]
  183. values = links[:len(links)/2]
  184. edges = links[len(links)/2:]
  185. yield [("CD", [a, c_value, b])] + \
  186. [("CD", [a, c_value + 1 + index, value]) for index, value in enumerate(values)] + \
  187. [("DE", [i]) for i in edges]
  188. raise PrimitiveFinished(a)
  189. def list_delete(a, b, **remainder):
  190. a_outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  191. links = yield [("RD", [a, i]) for i in range(b_value, len(a_outgoing))] + \
  192. [("RDE", [a, i]) for i in range(b_value, len(a_outgoing))]
  193. values = links[:len(links)/2]
  194. edges = links[len(links)/2:]
  195. yield [("CD", [a, b_value + index, value]) for index, value in enumerate(values[1:])] + \
  196. [("DE", [i]) for i in edges]
  197. raise PrimitiveFinished(a)
  198. def list_read(a, b, **remainder):
  199. b_value = yield [("RV", [b])]
  200. result = yield [("RD", [a, b_value])]
  201. if result is None:
  202. raise Exception("List read out of bounds: %s" % b_value)
  203. raise PrimitiveFinished(result)
  204. def list_len(a, **remainder):
  205. outgoings = yield [("RO", [a])]
  206. result = yield [("CNV", [len(outgoings)])]
  207. raise PrimitiveFinished(result)
  208. def dict_add(a, b, c, **remainder):
  209. new_edge = yield [("CE", [a, c])]
  210. yield [("CE", [new_edge, b])]
  211. raise PrimitiveFinished(a)
  212. def dict_delete(a, b, **remainder):
  213. edge = yield [("RDNE", [a, b])]
  214. if edge is None:
  215. # This exact node isn't in this dictionary, so delete everything matching the value instead
  216. b_value = yield [("RV", [b])]
  217. edge = yield [("RDE", [a, b_value])]
  218. yield [("DE", [edge])]
  219. raise PrimitiveFinished(a)
  220. def dict_read(a, b, **remainder):
  221. b_value = yield [("RV", [b])]
  222. result = yield [("RD", [a, b_value])]
  223. raise PrimitiveFinished(result)
  224. def dict_read_edge(a, b, **remainder):
  225. b_value = yield [("RV", [b])]
  226. result = yield [("RDE", [a, b_value])]
  227. raise PrimitiveFinished(result)
  228. def dict_read_node(a, b, **remainder):
  229. result = yield [("RDN", [a, b])]
  230. raise PrimitiveFinished(result)
  231. def dict_in(a, b, **remainder):
  232. b_value = yield [("RV", [b])]
  233. value = yield [("RD", [a, b_value])]
  234. is_in = value is not None
  235. result = yield [("CNV", [is_in])]
  236. raise PrimitiveFinished(result)
  237. def dict_in_node(a, b, **remainder):
  238. value = yield [("RDN", [a, b])]
  239. result = yield [("CNV", [value is not None])]
  240. raise PrimitiveFinished(result)
  241. def dict_len(a, **remainder):
  242. outgoings = yield [("RO", [a])]
  243. result = yield [("CNV", [len(outgoings)])]
  244. raise PrimitiveFinished(result)
  245. def dict_keys(a, **remainder):
  246. keys, result = yield [("RDK", [a]), ("CN", [])]
  247. yield [("CE", [result, v]) for v in keys]
  248. raise PrimitiveFinished(result)
  249. def is_physical_int(a, **remainder):
  250. t = yield [("RV", [a])]
  251. result = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
  252. raise PrimitiveFinished(result)
  253. def is_physical_string(a, **remainder):
  254. t = yield [("RV", [a])]
  255. result = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
  256. raise PrimitiveFinished(result)
  257. def is_physical_float(a, **remainder):
  258. t = yield [("RV", [a])]
  259. result = yield [("CNV", [isinstance(t, float)])]
  260. raise PrimitiveFinished(result)
  261. def is_physical_boolean(a, **remainder):
  262. t = yield [("RV", [a])]
  263. result = yield [("CNV", [isinstance(t, bool)])]
  264. raise PrimitiveFinished(result)
  265. def is_physical_action(a, **remainder):
  266. t = yield [("RV", [a])]
  267. result = yield [("CNV", [isinstance(t, dict) and t["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]])]
  268. raise PrimitiveFinished(result)
  269. def create_node(**remainder):
  270. result = yield [("CN", [])]
  271. raise PrimitiveFinished(result)
  272. def create_edge(a, b, **remainder):
  273. result = yield [("CE", [a, b])]
  274. raise PrimitiveFinished(result)
  275. def create_value(a, **remainder):
  276. a_value = yield [("RV", [a])]
  277. result = yield [("CNV", [a_value])]
  278. raise PrimitiveFinished(result)
  279. def read_nr_out(a, **remainder):
  280. outgoing = yield [("RO", [a])]
  281. result = yield [("CNV", [len(outgoing)])]
  282. raise PrimitiveFinished(result)
  283. def read_out(a, b, **remainder):
  284. outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  285. raise PrimitiveFinished(sorted(outgoing)[b_value])
  286. def read_nr_in(a, **remainder):
  287. incoming = yield [("RI", [a])]
  288. result = yield [("CNV", [len(incoming)])]
  289. raise PrimitiveFinished(result)
  290. def read_in(a, b, **remainder):
  291. incoming, b_value = yield [("RI", [a]), ("RV", [b])]
  292. raise PrimitiveFinished(sorted(incoming)[b_value])
  293. def read_edge_src(a, **remainder):
  294. result = yield [("RE", [a])]
  295. raise PrimitiveFinished(result[0])
  296. def read_edge_dst(a, **remainder):
  297. result = yield [("RE", [a])]
  298. raise PrimitiveFinished(result[1])
  299. def delete_element(a, **remainder):
  300. edge = yield [("RE", [a])]
  301. if edge[0] is None:
  302. # Not an edge:
  303. yield [("DN", [a])]
  304. result = yield [("CNV", [False])]
  305. raise PrimitiveFinished(result)
  306. else:
  307. yield [("DE", [a])]
  308. result = yield [("CNV", [True])]
  309. raise PrimitiveFinished(result)
  310. def read_root(root, **remainder):
  311. raise PrimitiveFinished(root)
  312. def set_add(a, b, **remainder):
  313. yield [("CE", [a, b])]
  314. raise PrimitiveFinished(a)
  315. def set_pop(a, **remainder):
  316. outgoing = yield [("RO", [a])]
  317. v, _ = yield [("RE", [outgoing[0]]), ("DE", [outgoing[0]])]
  318. raise PrimitiveFinished(v[1])
  319. def set_remove(a, b, **remainder):
  320. outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  321. elements = yield [("RE", [i]) for i in outgoing]
  322. elements = [elements] if not isinstance(elements[0], list) else elements
  323. values = yield [("RV", [i[1]]) for i in elements]
  324. values = [values] if not isinstance(values, list) else values
  325. yield [("DE", [identifier]) for identifier, edge in zip(outgoing, values) if edge == b_value]
  326. raise PrimitiveFinished(a)
  327. def set_remove_node(a, b, **remainder):
  328. outgoing = yield [("RO", [a])]
  329. elements = yield [("RE", [i]) for i in outgoing]
  330. elements = [elements] if not isinstance(elements[0], list) else elements
  331. yield [("DE", [identifier]) for identifier, edge in zip(outgoing, elements) if edge[1] == b]
  332. raise PrimitiveFinished(a)
  333. def set_in(a, b, **remainder):
  334. outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  335. if outgoing:
  336. elements = yield [("RE", [i]) for i in outgoing]
  337. elements = [elements] if not isinstance(elements[0], list) else elements
  338. values = yield [("RV", [i[1]]) for i in elements]
  339. values = [values] if not isinstance(values, list) else values
  340. if b_value in [v for v in values]:
  341. result = yield [("CNV", [True])]
  342. else:
  343. result = yield [("CNV", [False])]
  344. else:
  345. result = yield [("CNV", [False])]
  346. raise PrimitiveFinished(result)
  347. def set_in_node(a, b, **remainder):
  348. outgoing = yield [("RO", [a])]
  349. if outgoing:
  350. elements = yield [("RE", [i]) for i in outgoing]
  351. elements = [elements] if not isinstance(elements[0], list) else elements
  352. if b in [v[1] for v in elements]:
  353. result = yield [("CNV", [True])]
  354. else:
  355. result = yield [("CNV", [False])]
  356. else:
  357. result = yield [("CNV", [False])]
  358. raise PrimitiveFinished(result)
  359. def is_edge(a, **remainder):
  360. edge = yield [("RE", [a])]
  361. result = yield [("CNV", [edge[0] is not None])]
  362. raise PrimitiveFinished(result)
  363. #TODO deprecate
  364. def deserialize(a, root, **remainder):
  365. print("DESERIALIZE")
  366. value = yield [("RV", [a])]
  367. id_mappings = {}
  368. complex_primitives = frozenset(["if", "while", "assign", "call", "break", "continue", "return","resolve","access", "constant", "input", "output", "declare", "global"])
  369. for l in value.split("\n"):
  370. try:
  371. graph_type, constructor = l.split(None, 1)
  372. except:
  373. continue
  374. if graph_type == "N":
  375. # Node
  376. id_mappings[constructor] = yield [("CN", [])]
  377. elif graph_type == "V":
  378. # Node with Value
  379. name, temp = constructor.split("(", 1)
  380. string_value = temp[:-1]
  381. if string_value in complex_primitives:
  382. value = {"value": string_value}
  383. else:
  384. #TODO this is very dangerous!
  385. value = eval(string_value)
  386. id_mappings[name] = yield [("CNV", [value])]
  387. elif graph_type == "E":
  388. # Edge
  389. name, temp = constructor.split("(", 1)
  390. source, target = temp[:-1].split(",", 1)
  391. if target[0] == "?" and target not in id_mappings:
  392. hierarchy = target[1:].split("/")
  393. current = yield [("RD", [root, "__hierarchy"])]
  394. for i in hierarchy:
  395. current = yield [("RD", [current, i])]
  396. id_mappings[target] = current
  397. try:
  398. source = int(source)
  399. except:
  400. source = id_mappings[source]
  401. try:
  402. target = int(target)
  403. except:
  404. target = id_mappings[target]
  405. # Both nodes will normally be already present in the matching dictionary, so can just pass them along
  406. id_mappings[name] = yield [("CE", [source, target])]
  407. elif graph_type == "D":
  408. source, value, target = constructor.split(",",3)
  409. if value in complex_primitives:
  410. value = {"value": value}
  411. else:
  412. #TODO this is very dangerous!
  413. value = eval(value)
  414. if target[0] == "?" and target not in id_mappings:
  415. hierarchy = target[1:].split("/")
  416. current = yield [("RD", [root, "__hierarchy"])]
  417. for i in hierarchy:
  418. current = yield [("RD", [current, i])]
  419. id_mappings[target] = current
  420. try:
  421. source = int(source)
  422. except:
  423. source = id_mappings[source]
  424. try:
  425. target = int(target)
  426. except:
  427. target = id_mappings[target]
  428. yield [("CD", [source, value, target])]
  429. else:
  430. print("Unknown graph type: " + str(graph_type))
  431. raise PrimitiveFinished(id_mappings["auto_initial_IP"])
  432. def log(a, **remainder):
  433. a_value = yield [("RV", [a])]
  434. print("== LOG == " + str(a_value))
  435. raise PrimitiveFinished(a)