primitives.py 19 KB

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