primitives_visitor.py 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448
  1. import string
  2. from visitor import Visitor
  3. class PrimitivesVisitor(Visitor):
  4. def __init__(self, args):
  5. Visitor.__init__(self, args)
  6. self.output = []
  7. self.free_id = 0
  8. self.function_values = dict()
  9. self.debug_symbols = "--debug" in args
  10. def debug(self, node, tree, msg=""):
  11. if self.debug_symbols:
  12. self.dict(node, "__debug", self.value('"[%s] %s"' % (tree.get_reference_line(), msg)))
  13. def node(self):
  14. self.output.append(("N", self.free_id))
  15. self.free_id += 1
  16. return self.free_id - 1
  17. def dict(self, src, val, trgt):
  18. if src is None or trgt is None:
  19. print((src, val, trgt))
  20. raise Exception("Got None")
  21. if isinstance(val, str):
  22. val = "\"%s\"" % val
  23. self.output.append(("D", (src, val, trgt)))
  24. def value(self, value):
  25. self.output.append(("V", (self.free_id, value)))
  26. self.free_id += 1
  27. return self.free_id - 1
  28. def edge(self, source, target):
  29. self.output.append(("E", (self.free_id, source, target)))
  30. self.free_id += 1
  31. return self.free_id - 1
  32. def dump(self):
  33. output = []
  34. for t, data in self.output:
  35. if t == "N":
  36. output.append("N auto_%s\n" % data)
  37. elif t == "V":
  38. name, value = data
  39. name = name if self.first != name else "initial_IP"
  40. output.append("V auto_%s(%s)\n" % (name, value))
  41. elif t == "D":
  42. source, value, target = data
  43. source = source if self.first != source else "auto_initial_IP"
  44. target = target if self.first != target else "auto_initial_IP"
  45. source = "auto_%s" % source if isinstance(source, int) else source
  46. target = "auto_%s" % target if isinstance(target, int) else target
  47. output.append("D %s,%s,%s\n" % (source, value, target))
  48. elif t == "E":
  49. name, source, target = data
  50. source = source if self.first != source else "auto_initial_IP"
  51. target = target if self.first != target else "auto_initial_IP"
  52. name = "auto_%s" % name if isinstance(name, int) else name
  53. source = "auto_%s" % source if isinstance(source, int) else source
  54. target = "auto_%s" % target if isinstance(target, int) else target
  55. output.append("E %s(%s,%s)\n" % (name, source, target))
  56. return "".join(output)
  57. def set_primitive(self, tree, primitive):
  58. tree.primitive = primitive
  59. def get_primitive(self, tree):
  60. return getattr(tree, 'primitive', None)
  61. def forward_primitive_of_child(self, tree, i):
  62. self.visit_children(tree)
  63. self.set_primitive(tree, self.get_primitive(tree.get_tail()[i]))
  64. # a visit_* method for each non-terminal in the grammar
  65. def visit_start(self, tree):
  66. primitives = []
  67. for child in tree.get_children("funcdecl"):
  68. p = self.pre_visit_funcdecl(child)
  69. if p:
  70. # funcdecl returns a (global, assign) pair
  71. primitives.extend(p)
  72. for child in tree.get_tail():
  73. self.visit(child)
  74. p = self.get_primitive(child)
  75. if p is not None:
  76. if type(p) in (list, tuple):
  77. # funcdecl returns a (global, assign) pair
  78. primitives.extend(p)
  79. else:
  80. primitives.append(p)
  81. if child.head == "return":
  82. break
  83. self.first = primitives[0]
  84. for i in range(len(primitives)-1):
  85. self.dict(primitives[i], "next", primitives[i+1])
  86. self.last_instruction = primitives[-1]
  87. def visit_vardecl(self, tree):
  88. symbol = self.get_symbol(tree)
  89. if symbol.is_global:
  90. d = self.value("global")
  91. n = self.value('"%s"' % symbol.name)
  92. else:
  93. d = self.value("declare")
  94. n = self.node()
  95. symbol.node = n
  96. self.dict(d, "var", n)
  97. self.debug(d, tree)
  98. self.set_primitive(tree, d)
  99. def visit_assignment(self, tree):
  100. self.visit_children(tree)
  101. a = self.value("assign")
  102. var = self.get_primitive(tree.get_tail()[0])
  103. value = self.get_primitive(tree.get_tail()[-1])
  104. self.dict(a, "var", var)
  105. self.dict(a, "value", value)
  106. self.debug(a, tree)
  107. self.set_primitive(tree, a)
  108. def visit_expression(self, tree):
  109. self.forward_primitive_of_child(tree, 0)
  110. def visit_binary_operation(self, tree):
  111. self.forward_primitive_of_child(tree, 0)
  112. def visit_disjunction(self, tree):
  113. self.forward_primitive_of_child(tree, 0)
  114. def visit_conjunction(self, tree):
  115. self.forward_primitive_of_child(tree, 0)
  116. def visit_comparison(self, tree):
  117. self.forward_primitive_of_child(tree, 0)
  118. def visit_relation(self, tree):
  119. self.forward_primitive_of_child(tree, 0)
  120. def visit_sum(self, tree):
  121. self.forward_primitive_of_child(tree, 0)
  122. def visit_term(self, tree):
  123. self.forward_primitive_of_child(tree, 0)
  124. def visit_factor(self, tree):
  125. self.forward_primitive_of_child(tree, 0)
  126. def visit_primary(self, tree):
  127. self.forward_primitive_of_child(tree, 0)
  128. def visit_parenthesized(self, tree):
  129. self.forward_primitive_of_child(tree, 1)
  130. def visit_atomvalue(self, tree):
  131. self.forward_primitive_of_child(tree, 0)
  132. def visit_type_specifier(self, tree):
  133. self.visit_literal(tree)
  134. def visit_actionname(self, tree):
  135. self.visit_literal(tree.get_tail()[1])
  136. self.set_primitive(tree, self.get_primitive(tree.get_tail()[1]))
  137. def visit_string(self, tree):
  138. self.visit_literal(tree)
  139. # there is no such rule in the grammar, we just avoid code duplicates
  140. def visit_literal(self, tree):
  141. # TODO dictionary and list
  142. # if self.no_constant:
  143. # n = self.new_value(tree.get_text())
  144. # self.set_id(tree, n)
  145. # else:
  146. c = self.value("constant")
  147. n = self.value(tree.get_text())
  148. self.dict(c, "node", n)
  149. self.debug(c, tree)
  150. self.set_primitive(tree, c)
  151. def visit_integer(self, tree):
  152. self.visit_literal(tree)
  153. def visit_float(self, tree):
  154. self.visit_literal(tree)
  155. def visit_rvalue(self, tree):
  156. self.visit_lvalue(tree)
  157. r = self.get_primitive(tree)
  158. if r is None:
  159. return
  160. a = self.value("access")
  161. self.dict(a, "var", r)
  162. self.debug(a, tree)
  163. self.set_primitive(tree, a)
  164. def visit_lvalue(self, tree):
  165. symbol = self.get_symbol(tree)
  166. if symbol.name in ["input", "output"]:
  167. return
  168. r = self.value("resolve")
  169. # print symbol.name, symbol.is_func(), symbol.node
  170. self.dict(r, "var", symbol.node)
  171. self.debug(r, tree)
  172. self.set_primitive(tree, r)
  173. def visit_func_call(self, tree):
  174. self.visit_children(tree)
  175. symbol = self.get_symbol(tree.get_tail()[0])
  176. expressions = tree.get_children("expression")
  177. arg_nodes_reversed = []
  178. for i in reversed(range(len(expressions))):
  179. arg_name = '"{}"'.format(string.ascii_lowercase[i])
  180. arg_node = self.node()
  181. name_node = self.value(arg_name)
  182. self.dict(arg_node, "name", name_node)
  183. # print expressions[i].get_text()
  184. value_node = self.get_primitive(expressions[i])
  185. self.dict(arg_node, "value", value_node)
  186. if arg_nodes_reversed:
  187. next_node = arg_nodes_reversed[-1]
  188. self.dict(arg_node, "next_param", next_node)
  189. arg_nodes_reversed.append(arg_node)
  190. c = self.value("call")
  191. a = self.get_primitive(tree.get_tail()[0])
  192. self.dict(c, "func", a)
  193. self.debug(c, tree)
  194. if arg_nodes_reversed:
  195. self.dict(c, "params", arg_nodes_reversed[-1])
  196. self.dict(c, "last_param", arg_nodes_reversed[0])
  197. self.set_primitive(tree, c)
  198. def visit_input(self, tree):
  199. self.visit_children(tree)
  200. v = self.value("input")
  201. self.debug(v, tree)
  202. self.set_primitive(tree, v)
  203. def visit_output(self, tree):
  204. self.visit_children(tree)
  205. v = self.value("output")
  206. self.debug(v, tree)
  207. value = self.get_primitive(tree.get_child("expression"))
  208. self.dict(v, "value", value)
  209. self.set_primitive(tree, v)
  210. def visit_ifelse(self, tree):
  211. self.visit_children(tree)
  212. expressions = [self.get_primitive(e) for e in
  213. tree.get_children("expression")]
  214. blocks = [self.get_primitive(b) for b in tree.get_children("block")]
  215. first = None
  216. prev = None
  217. for e, b in zip(expressions, blocks):
  218. v = self.value("if")
  219. self.debug(v, tree)
  220. if first is None:
  221. first = v
  222. self.dict(v, "cond", e)
  223. self.dict(v, "then", b)
  224. if prev:
  225. self.dict(prev, "else", v)
  226. prev = v
  227. if len(expressions) != len(blocks):
  228. self.dict(prev, "else", blocks[-1])
  229. self.set_primitive(tree, first)
  230. def visit_while(self, tree):
  231. self.visit_children(tree)
  232. w = self.value("while")
  233. self.debug(w, tree)
  234. c = self.get_primitive(tree.get_child("expression"))
  235. b = self.get_primitive(tree.get_child("block"))
  236. self.dict(w, "cond", c)
  237. self.dict(w, "body", b)
  238. self.set_primitive(tree, w)
  239. def visit_block(self, tree):
  240. self.visit_children(tree)
  241. primitives = []
  242. for child in tree.get_tail():
  243. p = self.get_primitive(child)
  244. if p:
  245. primitives.append(p)
  246. if child.head == "return":
  247. break
  248. for i in range(len(primitives)-1):
  249. self.dict(primitives[i], "next", primitives[i+1])
  250. self.set_primitive(tree, primitives[0])
  251. def visit_func_body(self, tree):
  252. self.forward_primitive_of_child(tree, 0)
  253. def pre_visit_funcdecl(self, tree):
  254. symbol = self.get_symbol(tree)
  255. if symbol.name in ["input", "output"]:
  256. return
  257. # TODO: fix funcdecl special case: "X function f(...) = ..."
  258. # Note: replicates "Element x; x = ?primiteves/a" behavior
  259. # Dangerous: SemanticsVisitor handles it as a function
  260. if not tree.get_child("func_body"):
  261. return
  262. new_value = self.node()
  263. self.function_values[symbol.name] = new_value
  264. root = self.value('"%s"' % symbol.name)
  265. symbol.node = root
  266. declare = self.value("global")
  267. self.dict(declare, "var", root)
  268. resolve = self.value("resolve")
  269. self.dict(resolve, "var", root)
  270. assign = self.value("assign")
  271. self.dict(assign, "var", resolve)
  272. const = self.value("constant")
  273. self.dict(const, "node", new_value)
  274. self.dict(assign, "value", const)
  275. return declare, assign
  276. def visit_funcdecl(self, tree):
  277. symbol = self.get_symbol(tree)
  278. if symbol.name in ["input", "output"]:
  279. return
  280. func_body = tree.get_child("func_body")
  281. if func_body:
  282. self.visit_children(tree)
  283. vf = self.function_values[symbol.name]
  284. parameters = tree.get_children("parameter")
  285. if parameters:
  286. ps = self.node()
  287. self.dict(vf, "params", ps)
  288. for i in range(len(parameters)):
  289. n = self.get_primitive(parameters[i])
  290. self.dict(ps, string.ascii_lowercase[i], n)
  291. # Add the name in case we want to pre-compile in the MvK
  292. self.dict(n, "name", self.value('"%s"' % string.ascii_lowercase[i]))
  293. b = self.get_primitive(func_body)
  294. self.dict(vf, "body", b)
  295. else:
  296. # TODO: fix funcdecl special case: "X function f(...) = ..."
  297. # Note: replicates "Element x; x = ?primiteves/a" behavior
  298. # Dangerous: SemanticsVisitor handles it as a function
  299. root = self.value('"%s"' % symbol.name)
  300. symbol.node = root
  301. if tree.get_child("ASSIGN"):
  302. new_value = "?" + tree.get_child("ANYTHING").get_text()
  303. elif tree.get_child("ASSIGN") and not tree.get_child("ANYTHING"):
  304. new_value = self.node()
  305. else:
  306. return
  307. declare = self.value("global")
  308. self.dict(declare, "var", root)
  309. self.debug(declare, tree)
  310. resolve = self.value("resolve")
  311. self.dict(resolve, "var", root)
  312. assign = self.value("assign")
  313. self.dict(assign, "var", resolve)
  314. const = self.value("constant")
  315. self.dict(const, "node", new_value)
  316. self.dict(assign, "value", const)
  317. self.set_primitive(tree, (declare, assign))
  318. def visit_definition(self, tree):
  319. symbol = self.get_symbol(tree)
  320. root = self.value('"%s"' % symbol.name)
  321. declare = self.value("global")
  322. self.dict(declare, "var", root)
  323. self.debug(declare, tree)
  324. symbol.node = root
  325. resolve = self.value("resolve")
  326. self.dict(resolve, "var", root)
  327. assign = self.value("assign")
  328. self.dict(assign, "var", resolve)
  329. const = self.value("constant")
  330. self.visit_atomvalue(tree.get_tail()[-1])
  331. value = self.get_primitive(tree.get_tail()[-1])
  332. #TODO hack...
  333. if value is None:
  334. value = self.node()
  335. self.dict(const, "node", value)
  336. self.dict(assign, "value", const)
  337. self.set_primitive(tree, (declare, assign))
  338. def visit_parameter(self, tree):
  339. n = self.node()
  340. symbol = self.get_symbol(tree)
  341. symbol.node = n
  342. self.set_primitive(tree, n)
  343. def visit_return(self, tree):
  344. self.visit_children(tree)
  345. r = self.value("return")
  346. self.debug(r, tree)
  347. if len(tree.get_tail()) > 1:
  348. v = self.get_primitive(tree.get_tail()[1])
  349. self.dict(r, "value", v)
  350. self.set_primitive(tree, r)
  351. def visit_bool(self, tree):
  352. self.visit_literal(tree)