constructors.alc 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344
  1. include "primitives.alh"
  2. include "conformance_scd.alh"
  3. include "library.alh"
  4. include "io.alh"
  5. include "modelling.alh"
  6. Element while_stack = ?
  7. Element variable_map = ?
  8. Action function construct_top():
  9. String command
  10. while (True):
  11. command = input()
  12. if (command == "global"):
  13. return construct_global()
  14. elif (command == "funcdef"):
  15. return construct_top_funcdef()
  16. else:
  17. log("ERROR: did not understand command " + cast_e2s(command))
  18. Action function construct_global():
  19. Action this_element
  20. String declared_element
  21. String op
  22. log("Construct global")
  23. this_element = create_value(!global)
  24. declared_element = input()
  25. dict_add(this_element, "var", declared_element)
  26. // Defines
  27. Action assign
  28. Action resolve
  29. Action value
  30. assign = create_value(!assign)
  31. dict_add(this_element, "next", assign)
  32. resolve = create_value(!resolve)
  33. dict_add(assign, "var", resolve)
  34. dict_add(resolve, "var", declared_element)
  35. op = input()
  36. if (op == "deref"):
  37. value = create_value(!constant)
  38. dict_add(value, "node", import_node(input()))
  39. elif (op == "empty"):
  40. log("EMPTY")
  41. value = create_value(!call)
  42. Element res
  43. Element acc
  44. res = create_value(!resolve)
  45. acc = create_value(!access)
  46. dict_add(value, "func", acc)
  47. dict_add(acc, "var", res)
  48. dict_add(res, "var", "create_node")
  49. log("Created create_node call")
  50. elif (op == "const"):
  51. value = create_value(!constant)
  52. dict_add(value, "node", input())
  53. dict_add(assign, "value", value)
  54. if (input()):
  55. dict_add(assign, "next", construct_top())
  56. return this_element
  57. Action function construct_top_funcdef():
  58. Action assign
  59. Action resolve
  60. Action constant
  61. Element formal
  62. Element func
  63. Element params
  64. Action global
  65. String name
  66. global = create_value(!global)
  67. assign = create_value(!assign)
  68. resolve = create_value(!resolve)
  69. constant = create_value(!constant)
  70. name = input()
  71. if (dict_in(variable_map, name)):
  72. formal = dict_read(variable_map, name)
  73. else:
  74. formal = name
  75. func = create_node()
  76. params = create_node()
  77. dict_add(global, "var", formal)
  78. dict_add(global, "next", assign)
  79. dict_add(assign, "var", resolve)
  80. dict_add(assign, "value", constant)
  81. dict_add(resolve, "var", formal)
  82. dict_add(constant, "node", func)
  83. dict_add(func, "params", params)
  84. Integer nrParams
  85. nrParams = input()
  86. Integer counter
  87. counter = 0
  88. Element param
  89. String arg_names_decl
  90. arg_names_decl = "abcdefghijklmnopqrstuvwxyz"
  91. while (counter < nrParams):
  92. param = create_node()
  93. dict_add(params, string_get(arg_names_decl, counter), param)
  94. dict_add(param, "name", string_get(arg_names_decl, counter))
  95. dict_add(variable_map, input(), param)
  96. // Output each parameter in turn
  97. counter = counter + 1
  98. // Now add the body
  99. dict_add(func, "body", construct_unknown())
  100. if (input()):
  101. dict_add(assign, "next", construct_top())
  102. return global
  103. Action function construct_unknown():
  104. String elem
  105. Element new_model
  106. Element new_model_model
  107. elem = input()
  108. if (elem == "if"):
  109. return construct_if()
  110. elif (elem == "while"):
  111. return construct_while()
  112. elif (elem == "access"):
  113. return construct_access()
  114. elif (elem == "resolve"):
  115. return construct_resolve()
  116. elif (elem == "assign"):
  117. return construct_assign()
  118. elif (elem == "call"):
  119. return construct_call()
  120. elif (elem == "return"):
  121. return construct_return()
  122. elif (elem == "const"):
  123. return construct_const()
  124. elif (elem == "declare"):
  125. return construct_declare()
  126. elif (elem == "output"):
  127. return construct_output()
  128. elif (elem == "input"):
  129. return construct_input()
  130. elif (elem == "deref"):
  131. return construct_deref()
  132. elif (elem == "break"):
  133. return construct_break()
  134. elif (elem == "continue"):
  135. return construct_continue()
  136. elif (elem == "model"):
  137. construct_model()
  138. log("Constructed model")
  139. return construct_unknown()
  140. else:
  141. log("ERROR: did not understand command " + cast_e2s(elem))
  142. Action function construct_if():
  143. Action this_element
  144. this_element = create_value(!if)
  145. dict_add(this_element, "cond", construct_unknown())
  146. dict_add(this_element, "then", construct_unknown())
  147. if (input()):
  148. dict_add(this_element, "else", construct_unknown())
  149. if (input()):
  150. dict_add(this_element, "next", construct_unknown())
  151. return this_element
  152. Action function construct_while():
  153. Action this_element
  154. this_element = create_value(!while)
  155. dict_add(this_element, "cond", construct_unknown())
  156. list_append(while_stack, this_element)
  157. dict_add(this_element, "body", construct_unknown())
  158. list_delete(while_stack, list_len(while_stack) - 1)
  159. if (input()):
  160. dict_add(this_element, "next", construct_unknown())
  161. return this_element
  162. Action function construct_access():
  163. Action this_element
  164. this_element = create_value(!access)
  165. dict_add(this_element, "var", construct_unknown())
  166. return this_element
  167. Action function construct_resolve():
  168. Action this_element
  169. Element linked_element
  170. String name
  171. this_element = create_value(!resolve)
  172. name = input()
  173. if dict_in(variable_map, name):
  174. linked_element = variable_map[name]
  175. else:
  176. linked_element = name
  177. dict_add(this_element, "var", linked_element)
  178. return this_element
  179. Action function construct_assign():
  180. Action this_element
  181. this_element = create_value(!assign)
  182. dict_add(this_element, "var", construct_unknown())
  183. dict_add(this_element, "value", construct_unknown())
  184. if (input()):
  185. dict_add(this_element, "next", construct_unknown())
  186. return this_element
  187. Action function construct_call():
  188. Action this_element
  189. this_element = create_value(!call)
  190. dict_add(this_element, "func", construct_unknown())
  191. Integer nrParams
  192. nrParams = input()
  193. Integer counter
  194. counter = 0
  195. Element param
  196. Element prev_param
  197. String arg_names_call
  198. arg_names_call = "abcdefghijklmnopqrstuvwxyz"
  199. while (counter < nrParams):
  200. param = create_node()
  201. dict_add(param, "name", string_get(arg_names_call, counter))
  202. dict_add(param, "value", construct_unknown())
  203. if (counter == 0):
  204. dict_add(this_element, "params", param)
  205. else:
  206. dict_add(prev_param, "next_param", param)
  207. prev_param = param
  208. counter = counter + 1
  209. if (nrParams > 0):
  210. dict_add(this_element, "last_param", prev_param)
  211. if (input()):
  212. dict_add(this_element, "next", construct_unknown())
  213. return this_element
  214. Action function construct_return():
  215. if (input()):
  216. Action this_element
  217. this_element = create_value(!return)
  218. dict_add(this_element, "value", construct_unknown())
  219. return this_element
  220. else:
  221. return create_value(!return)
  222. Action function construct_const():
  223. Action this_element
  224. this_element = create_value(!constant)
  225. dict_add(this_element, "node", input())
  226. return this_element
  227. Action function construct_declare():
  228. Action this_element
  229. Element declared_element
  230. String name
  231. this_element = create_value(!declare)
  232. declared_element = create_node()
  233. dict_add(this_element, "var", declared_element)
  234. name = input()
  235. dict_add(variable_map, name, declared_element)
  236. if (input()):
  237. dict_add(this_element, "next", construct_unknown())
  238. return this_element
  239. Action function construct_input():
  240. Action this_element
  241. this_element = create_value(!input)
  242. return this_element
  243. Action function construct_output():
  244. Action this_element
  245. this_element = create_value(!output)
  246. dict_add(this_element, "value", construct_unknown())
  247. if (input()):
  248. dict_add(this_element, "next", construct_unknown())
  249. return this_element
  250. Action function construct_deref():
  251. Action this_element
  252. this_element = create_value(!constant)
  253. dict_add(this_element, "node", import_node(input()))
  254. return this_element
  255. Action function construct_break():
  256. Action this_element
  257. this_element = create_value(!break)
  258. dict_add(this_element, "while", while_stack[list_len(while_stack) - 1])
  259. return this_element
  260. Action function construct_continue():
  261. Action this_element
  262. this_element = create_value(!continue)
  263. dict_add(this_element, "while", while_stack[list_len(while_stack) - 1])
  264. return this_element
  265. Action function construct_function():
  266. Action func
  267. Integer nrParams
  268. Integer counter
  269. Element param
  270. Element params
  271. String arg_names_decl
  272. while (value_neq(input(), "funcdef")):
  273. // We skip over everything that is not a funcdef, as these are all just definitions of global stuff
  274. log("Skip over input!")
  275. // Consume the name
  276. input()
  277. params = create_node()
  278. nrParams = input()
  279. counter = 0
  280. func = create_node()
  281. arg_names_decl = "abcdefghijklmnopqrstuvwxyz"
  282. dict_add(func, "params", params)
  283. while (counter < nrParams):
  284. param = create_node()
  285. dict_add(params, string_get(arg_names_decl, counter), param)
  286. dict_add(variable_map, input(), param)
  287. // Output each parameter in turn
  288. counter = counter + 1
  289. // Now add the body
  290. dict_add(func, "body", construct_unknown())
  291. // Consume the final 'false', to indicate that no additional code will come
  292. input()
  293. return func