spacepaste

Paste details

reply | raw

  1.  
  2. #include "../Shell/builtins/printfmacro.h"
  3. #include "mpc/mpc.h"
  4. #include "mpc/mpc.c"
  5. #include <stdbool.h>
  6. #include "../Shell/builtins/libstring.h"
  7. #include "../Shell/builtins/regex_str.h"
  8. #include "../Shell/builtins/env.h"
  10. char * outfile = "tmpfile.c";
  12. void piece(mpc_ast_t *a, bool is_segmented, bool is_word, bool is_number, struct regex_string * b1, struct regex_string * b2) {
  13. str_reg(a->tag);
  14. // if (is_segmented) ps(a->tag)
  15. // if ((((str_is("word|regex") || str_is("word_segmented|word|regex"))) || ((str_is("char") || str_is("number|regex") || str_is("number_segmented|number|regex"))))) {
  16. // puts("START");
  17. // pb(is_word)
  18. // pb(is_number)
  19. // pb(is_segmented)
  20. // ps(a->tag)
  21. // puts("END");
  22. // }
  23. if(str_is("name_segmented|>") || str_is("indexedname_segmented|>")) {
  24. puts("attempting to piece together segmented name");
  25. int i = 0;
  26. for (i = 0; i < a->children_num; i++) {
  27. piece(a->children[i], true, true, false, b1, b2);
  28. }
  29. puts("attempted");
  30. }
  31. else if ((((str_is("word|regex") || str_is("word_segmented|word|regex")) && is_word) || ((str_is("char") || str_is("number|regex") || str_is("number_segmented|number|regex")) && is_number)) && is_segmented) {
  32. if (a->contents != NULL) {
  33. ps(a->contents);
  34. if (is_number) {
  35. if (b1 != NULL) {
  36. if (a->contents[0] != '#') str_insert_string(*b1, a->contents)
  37. }
  38. }
  39. else if(is_word) {
  40. if (b2 != NULL) {
  41. str_insert_string(*b2, a->contents)
  42. }
  43. }
  44. }
  45. }
  46. else if (str_is("word_segmented|>") && is_segmented) {
  47. puts("attempting to piece together segmented word");
  48. int i = 0;
  49. for (i = 0; i < a->children_num; i++) {
  50. piece(a->children[i], is_segmented, true, false, b1, b2);
  51. }
  52. puts("attempted");
  53. }
  54. else if (str_is("num_segmented|>")) {
  55. puts("attempting to piece together segmented number");
  56. int i = 0;
  57. for (i = 0; i < a->children_num; i++) {
  58. piece(a->children[i], true, false, true, b1, b2);
  59. }
  60. puts("attempted");
  61. }
  62. else if (str_is("number_segmented|>") && is_segmented) {
  63. puts("attempting to piece together segmented number");
  64. int i = 0;
  65. for (i = 0; i < a->children_num; i++) {
  66. piece(a->children[i], is_segmented, false, true, b1, b2);
  67. }
  68. puts("attempted");
  69. }
  70. }
  72. static void AP(mpc_ast_t *a, int d, FILE *fp) {
  74. int i;
  76. if (a == NULL) {
  77. fprintf(fp, "NULL\n");
  78. return;
  79. }
  81. for (i = 0; i < d; i++) { fprintf(fp, " "); }
  82. if (strlen(a->contents)) {
  83. fprintf(fp, "tag: '%s', contents: '%s'\n", a->tag,
  84. a->contents);
  85. } else {
  86. fprintf(fp, "tag: '%s' \n", a->tag);
  87. }
  89. for (i = 0; i < a->children_num; i++) {
  90. AP(a->children[i], d+1, fp);
  91. }
  93. }
  95. bool find_tree_string(mpc_ast_t *a, char * string) {
  96. int i;
  97. if (a == NULL) {
  98. printf("NULL\n");
  99. return false;
  100. }
  101. if (strcmp(a->contents, string) == 0) {
  102. // str_new(tmp);
  103. // str_insert_string(tmp, "puts(\"");
  104. // str_insert_string(tmp, a->contents);
  105. // str_insert_string(tmp, " \");\n");
  106. // str_output_append(tmp.indented, outfile);
  107. // str_free(tmp);
  108. return true;
  109. }
  110. return false;
  111. }
  113. bool find_tree_string2(mpc_ast_t *a) {
  114. int i;
  115. if (a == NULL) {
  116. printf("NULL\n");
  117. return false;
  118. }
  119. if (strcmp(a->tag, "ISA_DEFINE|word|regex") == 0 || strcmp(a->tag, "word|regex") == 0 ) {
  120. // str_new(tmp);
  121. // str_insert_string(tmp, "puts(\"");
  122. // str_insert_string(tmp, a->contents);
  123. // str_insert_string(tmp, " \");\n");
  124. // str_output_append(tmp.indented, outfile);
  125. // str_free(tmp);
  126. return true;
  127. } else if (strcmp(a->tag, "ISA_DEFINE|>") == 0) {
  128. for (i = 0; i < a->children_num; i++) {
  129. if (find_tree_string2(a->children[i]) == true) return true;
  130. }
  131. }
  132. return false;
  133. }
  134. int find_definition_strings_called = 0;
  135. bool find_definition_strings(mpc_ast_t *a, bool omit_else) {
  136. if (a == NULL) {
  137. printf("NULL\n");
  138. return false;
  139. }
  140. if (strcmp(a->tag, "word|regex") == 0) {
  141. find_definition_strings_called++;
  142. printf("%s\n", a->contents);
  143. str_new(tmp);
  144. if (omit_else == false) if (find_definition_strings_called >1) str_insert_string(tmp, "else ");
  145. str_insert_string(tmp, "if (!");
  146. str_insert_string(tmp, "regexEngineb(");
  147. str_insert_int(tmp, strlen(a->contents));
  148. str_insert_string(tmp, ", ");
  149. str_insert_int(tmp, strlen(a->contents));
  150. str_insert_string(tmp, ", \"");
  151. if (strlen(a->contents) != 1) {
  152. str_insert_int(tmp, strlen(a->contents)-1);
  153. str_insert_string(tmp, "-");
  154. }
  155. str_insert_string(tmp, "0,");
  156. str_insert_string(tmp, a->contents);
  157. str_insert_string(tmp, "\", binstr.data, ");
  158. if (find_definition_strings_called >1) { str_insert_string(tmp, "true"); }
  159. else { str_insert_string(tmp, "false"); }
  160. str_insert_string(tmp, ")");
  161. str_insert_string(tmp, ") {");
  162. // str_insert_string(tmp, "printf(\"a->contents = ");
  163. // str_insert_string(tmp, a->contents);
  164. // str_insert_string(tmp, ", regexEngineb_bits = %s\\n\", regexEngineb_bits);\n");
  165. str_insert_string(tmp, "}");
  166. str_output_append(tmp.indented, outfile);
  167. str_free(tmp);
  168. }
  170. return false;
  171. }
  173. bool find_definition_items(mpc_ast_t *a) {
  174. int i;
  175. if (a == NULL) {
  176. printf("NULL\n");
  177. return false;
  178. }
  179. if (strcmp(a->tag, "item|bracketed_item|>") == 0) {
  180. for (i = 0; i < a->children_num; i++) {
  181. find_definition_strings(a->children[i], true);
  182. }
  183. }
  184. else if (strcmp(a->tag, "item|normal_item|>") == 0) {
  185. for (i = 0; i < a->children_num; i++) {
  186. find_definition_strings(a->children[i], false);
  187. }
  188. }
  189. else {
  190. for (i = 0; i < a->children_num; i++) {
  191. find_definition_items(a->children[i]);
  192. }
  193. }
  194. return false;
  195. }
  197. bool find_definition_statements(mpc_ast_t *a) {
  198. int i;
  199. if (a == NULL) {
  200. printf("NULL\n");
  201. return false;
  202. }
  203. if (strcmp(a->tag, "definition_statement|>") == 0) {
  204. for (i = 0; i < a->children_num; i++) {
  205. find_definition_items(a->children[i]);
  206. }
  207. }
  208. else {
  209. for (i = 0; i < a->children_num; i++) {
  210. find_definition_statements(a->children[i]);
  211. }
  212. }
  213. return false;
  214. }
  216. bool find_definition_root(mpc_ast_t *a, char * string) {
  217. int i;
  218. if (a == NULL) {
  219. printf("NULL\n");
  220. return false;
  221. }
  222. if (strcmp(a->tag, "root|definition|>") == 0) {
  223. find_definition_strings_called = 0;
  224. for (i = 0; i < a->children_num; i++) {
  225. if (find_definition_root(a->children[i], string) == true) find_definition_statements(a);
  226. }
  227. find_definition_strings_called = 0;
  228. }
  229. else if (strcmp(a->tag, "definition_start|>") == 0) {
  230. for (i = 0; i < a->children_num; i++) {
  231. if (find_tree_string(a->children[i], string) == true) return true;
  232. }
  233. }
  234. else {
  235. for (i = 0; i < a->children_num; i++) {
  236. find_definition_root(a->children[i], string);
  237. }
  238. }
  239. return false;
  240. }
  242. bool find_instruction_root(mpc_ast_t *a) {
  243. int i;
  244. if (a == NULL) {
  245. printf("NULL\n");
  246. return false;
  247. }
  248. if (strcmp(a->tag, "root|instruction|>") == 0) {
  249. for (i = 0; i < a->children_num; i++) {
  250. find_instruction_root(a->children[i]);
  251. }
  252. }
  253. else if (strcmp(a->tag, "instruction_start|>") == 0) {
  254. for (i = 0; i < a->children_num; i++) {
  255. if (find_tree_string2(a->children[i]) == true) return true;
  256. }
  257. }
  258. else {
  259. for (i = 0; i < a->children_num; i++) {
  260. find_instruction_root(a->children[i]);
  261. }
  262. }
  263. return false;
  264. }
  266. void aquire_action_code(mpc_ast_t *a, struct regex_string * r) {
  267. if (a->children_num) {
  268. str_reg(a->children[0]->tag);
  269. if (str_is("name|>") || str_is("num|>") || str_is("indexedname|>") || str_is("name_segmented|>") || str_is("num_segmented|>") || str_is("indexedname_segmented|>")) return;
  270. }
  271. // str_insert_string(*r, "\n/*ACTION CODE BEGIN*/");
  272. int i = 0;
  273. for (i = 0; i < a->children_num; i++) {
  274. str_reg(a->children[i]->tag);
  275. if (str_is("regex")) {
  276. if (a->children[i]->contents != NULL) {
  277. str_insert_string(*r, a->children[i]->contents);
  278. }
  279. }
  280. }
  281. // str_insert_string(*r, "/*ACTION CODE END*/\n");
  282. }
  284. struct action_code_builder_object_references {
  285. int argv_id; // argv index
  286. int * content_id; // content index indexes
  287. int content_amount;
  288. int occurence_number;
  289. int instances;
  290. };
  292. struct action_code_builder_references {
  293. int argc;
  294. env_t argv;
  295. struct action_code_builder_object_references * ref;
  296. struct action_code_builder_content * content;
  297. int instances;
  298. };
  300. struct action_code_builder_content {
  301. struct regex_string content; // content of action code
  302. int instances;
  303. };
  305. struct action_code_builder {
  306. struct action_code_builder_references * references;
  307. int instances;
  308. } * action_code_builder_struct;
  310. int action_code_builder_argument_index = 0;
  312. void Build_Action_Code_Structure_Quick_Scan(mpc_ast_t *a, int * Build_Action_Code_Structure_Quick_Scan_Matches) {
  313. int i;
  315. if (a == NULL) {
  316. return;
  317. }
  319. bool is_an_action_structure = false;
  320. bool is_an_action_segmented_structure = false;
  321. bool has_tag = false;
  323. if (strlen(a->tag)) has_tag = true;
  325. if (has_tag) {
  326. if (strcmp(a->tag, "action_code|>") == 0) is_an_action_structure = true;
  327. else if (strcmp(a->tag, "action_code_segmented|>") == 0) is_an_action_segmented_structure = true;
  328. }
  330. if (!is_an_action_structure && !is_an_action_segmented_structure) for (i = 0; i < a->children_num; i++) {
  331. Build_Action_Code_Structure_Quick_Scan(a->children[i], Build_Action_Code_Structure_Quick_Scan_Matches);
  332. }
  333. else (*Build_Action_Code_Structure_Quick_Scan_Matches)++;
  334. }
  336. struct binder {
  337. int bind_index;
  338. int bind_index_old;
  339. bool bind_index_updated;
  340. bool bind_segmented;
  341. int bind_type;
  342. char * target_content_name;
  343. int instances;
  344. } * action_code_binder;
  345. int action_code_binder_skip_next = 0;
  346. #define BIND_NONE -1
  347. #define BIND_NAME 1
  348. #define BIND_NUM 2
  349. #define BIND_FUSED 3
  351. void Build_Action_Code_Structure(mpc_ast_t *a, int d, bool is_sub_contents_part_of_action, bool renew) {
  352. if (renew) {
  353. if (action_code_builder_struct == NULL) {
  354. action_code_builder_struct = malloc(sizeof(struct action_code_builder)*1);
  355. action_code_builder_struct->instances = 1;
  357. action_code_builder_struct[action_code_builder_struct->instances-1].references = malloc(sizeof(struct action_code_builder_references)*1);
  358. action_code_builder_struct[action_code_builder_struct->instances-1].references->instances = 1;
  359. action_code_builder_struct[action_code_builder_struct->instances-1].references->argc = 0;
  360. action_code_builder_struct[action_code_builder_struct->instances-1].references->argv = NULL;
  361. action_code_builder_struct[action_code_builder_struct->instances-1].references->content = NULL;
  362. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref = malloc(sizeof(struct action_code_builder_object_references)*1);
  363. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances = 1;
  364. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->argv_id = -1;
  365. }
  366. else {
  367. action_code_builder_struct = realloc(action_code_builder_struct, sizeof(struct action_code_builder)*(action_code_builder_struct->instances+1));
  368. action_code_builder_struct->instances++;
  370. action_code_builder_struct[action_code_builder_struct->instances-1].references = malloc(sizeof(struct action_code_builder_references)*1);
  371. action_code_builder_struct[action_code_builder_struct->instances-1].references->instances = 1;
  372. action_code_builder_struct[action_code_builder_struct->instances-1].references->argc = 0;
  373. action_code_builder_struct[action_code_builder_struct->instances-1].references->argv = NULL;
  374. action_code_builder_struct[action_code_builder_struct->instances-1].references->content = NULL;
  375. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref = malloc(sizeof(struct action_code_builder_object_references)*1);
  376. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances = 1;
  377. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->argv_id = -1;
  378. }
  379. }
  380. int i;
  382. if (a == NULL) {
  383. return;
  384. }
  385. bool is_an_action = false;
  386. bool is_an_action_structure = false;
  387. bool is_an_action_segmented_structure = false;
  388. bool has_tag = false;
  389. bool has_contents = false;
  391. if (strlen(a->tag)) has_tag = true;
  392. if (strlen(a->contents)) has_contents = true;
  394. if (has_tag) {
  395. if (strcmp(a->tag, "action|>") == 0) is_an_action = true;
  396. else if (strcmp(a->tag, "action_code|>") == 0) is_an_action_structure = true;
  397. else if (strcmp(a->tag, "action_code_segmented|>") == 0) is_an_action_segmented_structure = true;
  399. if (is_an_action_segmented_structure || is_an_action_structure) is_sub_contents_part_of_action = true;
  401. if (!is_sub_contents_part_of_action || is_an_action_structure || is_an_action_segmented_structure) {
  402. if (action_code_binder != NULL) {
  403. puts("FREEING BINDER");
  404. free(action_code_binder);
  405. action_code_binder = NULL;
  406. }
  407. }
  408. pb(is_sub_contents_part_of_action);
  410. if (is_sub_contents_part_of_action == false && (strcmp(a->tag, "ISA_DEFINE|word|regex") == 0 || strcmp(a->tag, "ISA_RULE|word|regex") == 0 || strcmp(a->tag, "word|regex") == 0 || strcmp(a->tag, "binary|regex") == 0)) {
  411. if (action_code_builder_struct[action_code_builder_struct->instances-1].references->ref != NULL && action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->argv_id != -1) {
  412. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref = realloc(
  413. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref,
  414. sizeof(
  415. struct action_code_builder_object_references
  416. )
  417. *
  418. (
  419. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances+1
  420. )
  421. );
  422. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances++;
  423. }
  424. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances-1].content_id = NULL;
  425. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances-1].content_amount = 0;
  427. action_code_builder_struct[action_code_builder_struct->instances-1].references->argc++;
  429. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances-1].argv_id = action_code_builder_struct[action_code_builder_struct->instances-1].references->argc-1;
  431. action_code_builder_struct[action_code_builder_struct->instances-1].references->argv = env__add2(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv, a->contents);
  433. int occurence = 0, tag_index = action_code_builder_struct[action_code_builder_struct->instances-1].references->argc-1;
  434. for (int i = 0; i < tag_index; i++) if (strcmp(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[i], action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[tag_index]) == 0) occurence++;
  435. pi(occurence)
  436. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances-1].occurence_number = occurence;
  437. ps(a->contents)
  438. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->argc-1)
  439. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances-1].argv_id)
  440. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[0].argv_id)
  441. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances-1)
  442. }
  443. }
  445. if (is_sub_contents_part_of_action) {
  446. // how to build the structure of a reference...
  447. if (has_tag) {
  448. // try to get tag type
  449. str_reg(a->tag);
  450. if (str_is("name|>")) {
  451. if (action_code_binder_skip_next != 0) {
  452. action_code_binder_skip_next--;
  453. } else {
  454. puts("BINDING");
  455. if (action_code_binder == NULL) {
  456. action_code_binder = malloc(sizeof(struct binder)*1);
  457. action_code_binder->instances = 1;
  458. action_code_binder_skip_next = 0;
  459. }
  460. else {
  461. action_code_binder = realloc(action_code_binder, sizeof(struct binder)*(action_code_binder->instances+1));
  462. action_code_binder->instances++;
  463. }
  464. action_code_binder[action_code_binder->instances-1].target_content_name = a->children[1]->contents;
  465. action_code_binder[action_code_binder->instances-1].bind_index = 0;
  466. action_code_binder[action_code_binder->instances-1].bind_index_updated = false;
  467. action_code_binder[action_code_binder->instances-1].bind_type = BIND_NAME;
  468. }
  469. }
  470. else if (str_is("num|>")) {
  471. if (action_code_binder_skip_next != 0) {
  472. action_code_binder_skip_next--;
  473. } else {
  474. puts("BINDING");
  475. if (action_code_binder == NULL) {
  476. action_code_binder = malloc(sizeof(struct binder)*1);
  477. action_code_binder->instances = 1;
  478. action_code_binder_skip_next = 0;
  479. }
  480. else {
  481. action_code_binder = realloc(action_code_binder, sizeof(struct binder)*(action_code_binder->instances+1));
  482. action_code_binder->instances++;
  483. }
  484. action_code_binder[action_code_binder->instances-1].target_content_name = NULL;
  485. action_code_binder[action_code_binder->instances-1].bind_index = atoi(a->children[1]->contents);
  486. action_code_binder[action_code_binder->instances-1].bind_index_updated = false;
  487. action_code_binder[action_code_binder->instances-1].bind_type = BIND_NUM;
  488. pp(action_code_binder)
  489. }
  490. }
  491. else if (str_is("indexedname|>")) {
  492. if (action_code_binder_skip_next != 0) {
  493. action_code_binder_skip_next--;
  494. } else {
  495. puts("BINDING");
  496. if (action_code_binder == NULL) {
  497. action_code_binder = malloc(sizeof(struct binder)*1);
  498. action_code_binder->instances = 1;
  499. action_code_binder_skip_next = 0;
  500. }
  501. else {
  502. action_code_binder = realloc(action_code_binder, sizeof(struct binder)*(action_code_binder->instances+1));
  503. action_code_binder->instances++;
  504. }
  505. action_code_binder[action_code_binder->instances-1].target_content_name = a->children[1]->contents;
  506. action_code_binder[action_code_binder->instances-1].bind_index= atoi(a->children[2]->children[1]->contents);
  507. action_code_binder[action_code_binder->instances-1].bind_index_updated = false;
  508. action_code_binder[action_code_binder->instances-1].bind_type = BIND_FUSED;
  509. action_code_binder_skip_next = 1;
  510. }
  511. }
  512. else if (str_is("name_segmented|>")) {
  513. if (action_code_binder_skip_next != 0) {
  514. action_code_binder_skip_next--;
  515. } else {
  516. puts("BINDING");
  517. if (action_code_binder == NULL) {
  518. action_code_binder = malloc(sizeof(struct binder)*1);
  519. action_code_binder->instances = 1;
  520. }
  521. else {
  522. action_code_binder = realloc(action_code_binder, sizeof(struct binder)*(action_code_binder->instances+1));
  523. action_code_binder->instances++;
  524. }
  525. str_new(name__)
  526. piece(a, false, false, false, NULL, &name__);
  527. action_code_binder[action_code_binder->instances-1].target_content_name = strdup(name__.string);
  528. ps(name__.string)
  529. str_free(name__);
  530. action_code_binder[action_code_binder->instances-1].bind_index = 0;
  531. action_code_binder[action_code_binder->instances-1].bind_index_updated = false;
  532. action_code_binder[action_code_binder->instances-1].bind_type = BIND_NAME;
  533. }
  534. }
  535. else if (str_is("num_segmented|>")) {
  536. if (action_code_binder_skip_next != 0) {
  537. action_code_binder_skip_next--;
  538. } else {
  539. puts("BINDING");
  540. if (action_code_binder == NULL) {
  541. action_code_binder = malloc(sizeof(struct binder)*1);
  542. action_code_binder->instances = 1;
  543. }
  544. else {
  545. action_code_binder = realloc(action_code_binder, sizeof(struct binder)*(action_code_binder->instances+1));
  546. action_code_binder->instances++;
  547. }
  548. str_new(index__)
  549. piece(a, false, false, false, &index__, NULL);
  550. ps(index__.string)
  551. action_code_binder[action_code_binder->instances-1].target_content_name = NULL;
  552. action_code_binder[action_code_binder->instances-1].bind_index= atoi(strdup(index__.string));
  553. action_code_binder[action_code_binder->instances-1].bind_index_updated = false;
  554. str_free(index__);
  555. action_code_binder[action_code_binder->instances-1].bind_type = BIND_NUM;
  556. }
  557. }
  558. else if (str_is("indexedname_segmented|>")) {
  559. if (action_code_binder_skip_next != 0) {
  560. action_code_binder_skip_next--;
  561. } else {
  562. puts("BINDING");
  563. if (action_code_binder == NULL) {
  564. action_code_binder = malloc(sizeof(struct binder)*1);
  565. action_code_binder->instances = 1;
  566. }
  567. else {
  568. action_code_binder = realloc(action_code_binder, sizeof(struct binder)*(action_code_binder->instances+1));
  569. action_code_binder->instances++;
  570. }
  571. str_new(index__);
  572. str_new(name__);
  573. piece(a, false, false, false, &index__, &name__);
  574. ps(index__.string)
  575. ps(name__.string)
  576. action_code_binder[action_code_binder->instances-1].target_content_name = strdup(name__.string);
  577. str_free(name__);
  578. action_code_binder[action_code_binder->instances-1].bind_index= atoi(strdup(index__.string));
  579. action_code_binder[action_code_binder->instances-1].bind_index_updated = false;
  580. pi(action_code_binder[action_code_binder->instances-1].bind_index)
  581. str_free(index__);
  582. action_code_binder[action_code_binder->instances-1].bind_type = BIND_FUSED;
  583. action_code_binder_skip_next = 1;
  584. }
  585. }
  586. pp(action_code_binder)
  587. if (is_an_action) pp(action_code_binder)
  588. if (is_an_action && action_code_binder != NULL) {
  589. pp(action_code_binder)
  590. for (int ii = 0; ii < action_code_binder->instances; ii++) {
  591. printf("action_code_binder[%d].target_content_name = %s\n", ii, action_code_binder[ii].target_content_name);
  592. printf("action_code_binder[%d].bind_index = %d\n", ii, action_code_binder[ii].bind_index);
  593. printf("action_code_binder[%d].bind_index_updated = %s\n", ii, action_code_binder[ii].bind_index_updated==true?"true":"false");
  594. }
  595. for (int ii = 0; ii < action_code_binder->instances; ii++) {
  596. if (action_code_binder[action_code_binder->instances-1].bind_index_updated) {
  597. printf("occurence number %d of target %s has already been found, skipping\n", action_code_binder[ii].bind_index_old, action_code_binder[ii].target_content_name);
  598. continue;
  599. }
  600. if (action_code_binder[ii].bind_type == BIND_NAME || action_code_binder[ii].bind_type == BIND_FUSED) {
  601. ps(action_code_binder[ii].target_content_name);
  602. pi(action_code_binder[action_code_binder->instances-1].bind_index)
  603. printf("target occurence number is %d\n", action_code_binder[ii].bind_index);
  604. int tag_index = action_code_builder_struct[action_code_builder_struct->instances-1].references->argc-1;
  605. for (int i = 0; i < action_code_builder_struct[action_code_builder_struct->instances-1].references->argc; i++) {
  606. if (strcmp(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[i], action_code_binder[ii].target_content_name) == 0) {
  607. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[i].argv_id]);
  608. printf("target %s found, occurence number is %d, wanted occurence number is %d\n", action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[i], action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[i].occurence_number, action_code_binder[ii].bind_index);
  609. if (action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[i].occurence_number == action_code_binder[ii].bind_index) {
  610. printf("occurence number %d of target %s found\n", action_code_binder[ii].bind_index, action_code_binder[ii].target_content_name);
  611. action_code_binder[ii].bind_index_old = action_code_binder[ii].bind_index;
  612. action_code_binder[ii].bind_index = i;
  613. action_code_binder[ii].bind_index_updated = true;
  614. break;
  615. }
  616. }
  617. }
  618. if (action_code_binder[ii].bind_index_updated == false) {
  619. printf("error: occurence number %d of target %s not found, aborting execution\n", action_code_binder[ii].bind_index, action_code_binder[ii].target_content_name);
  620. abort();
  621. }
  622. pb(action_code_binder[ii].bind_index_updated)
  623. pi(action_code_binder[ii].bind_index)
  624. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].argv_id);
  625. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].occurence_number);
  626. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].argv_id]);
  627. }
  628. else if (action_code_binder[ii].bind_type == BIND_NUM) {
  629. pi(action_code_binder[ii].bind_index)
  630. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].argv_id);
  631. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].occurence_number);
  632. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].argv_id]);
  633. }
  634. }
  635. /*
  636. *
  637. * unsure about exact operation mode
  638. *
  639. * #0${NULL#0}$NULL$1 {/*NULL1*\/} {/*NULL2*\/}
  640. *
  641. * >>>
  642. *
  643. * #0 > arg id 0, first occurence
  644. * #0 > condent id 0 > {/*NULL1*\/}
  645. * #0 > condent id 1 > {/*NULL2*\/}
  646. *
  647. * ${NULL#0} > arg id 0, first occurence
  648. * ${NULL#0} > condent id 0 > {/*NULL1*\/}
  649. * ${NULL#0} > condent id 1 > {/*NULL2*\/}
  650. *
  651. * $NULL > arg id 0, first occurence
  652. * $NULL > condent id 0 > {/*NULL1*\/}
  653. * $NULL > condent id 1 > {/*NULL2*\/}
  654. *
  655. * #1 > arg id 1, first occurence
  656. * #1 > condent id 0 > {/*NULL1*\/}
  657. * #1 > condent id 1 > {/*NULL2*\/}
  658. *
  659. * each paramater is assigned a reference containing an argv id and a content id array
  660. *
  661. * */
  663. // implements multi action code storage (operation of the content id array), probably does not function correctly
  665. /*
  666. * current result:
  668. action_code_binder[ii].bind_index = 0
  670. action_code_binder[ii].bind_index = 0
  672. action_code_binder[ii].bind_index = 0
  674. action_code_binder[ii].bind_index = 1
  675. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[0].bind_index (0)].content_amount = 3
  676. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[0].bind_index (0)].content_id[0] = 0
  677. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[0].bind_index (0)].content_id[1] = 0
  678. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[0].bind_index (0)].content_id[2] = 0
  679. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[1].bind_index (0)].content_amount = 3
  680. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[1].bind_index (0)].content_id[0] = 0
  681. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[1].bind_index (0)].content_id[1] = 0
  682. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[1].bind_index (0)].content_id[2] = 0
  683. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[2].bind_index (0)].content_amount = 3
  684. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[2].bind_index (0)].content_id[0] = 0
  685. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[2].bind_index (0)].content_id[1] = 0
  686. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[2].bind_index (0)].content_id[2] = 0
  687. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[3].bind_index (1)].content_amount = 1
  688. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[3].bind_index (1)].content_id[0] = 1
  689. */
  690. if (is_an_action) {
  691. pp(action_code_builder_struct[action_code_builder_struct->instances-1].references->content)
  692. // get action code contents
  693. if (action_code_builder_struct[action_code_builder_struct->instances-1].references->content == NULL) {
  694. action_code_builder_struct[action_code_builder_struct->instances-1].references->content = malloc(sizeof(struct action_code_builder_content)*1);
  695. action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances = 1;
  696. }
  697. else {
  698. action_code_builder_struct[action_code_builder_struct->instances-1].references->content = realloc(action_code_builder_struct[action_code_builder_struct->instances-1].references->content, sizeof(struct action_code_builder_content)*(action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances+1));
  699. action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances++;
  700. }
  701. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1)
  702. // action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1].content = &actioncode;
  704. puts("MALLOCING NEW STRING");
  706. str_mallocr(action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1].content, 1);
  708. puts("ASSIGNING NEW STRING");
  710. aquire_action_code(a, &action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1].content);
  712. puts("PRINTING NEW STRING");
  714. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1].content.string);
  716. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->content->content.string);
  718. printf("action_code_builder_struct[action_code_builder_struct->instances-1].references->content[%d].content.string = %s\n", action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1, action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1].content.string);
  720. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances)
  721. env_t index_check = env__new();
  722. for (int ii = 0; ii < action_code_binder->instances; ii++) {
  723. // itterate through the bind indexes
  724. str_int2string(idx, action_code_binder[ii].bind_index);
  725. if (env__get_name(index_check, idx) != NULL) continue;
  726. ps(idx)
  727. index_check = env__add2(index_check, idx);
  728. env__print(index_check, idx);
  729. puts("");
  730. pi(action_code_binder[ii].bind_index)
  731. // creates an instance of content_id for each bind reference, this should not happen
  732. // instead create an instance of content_id for each action code
  733. if (action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_id == NULL) {
  734. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_id = malloc(sizeof(int)*1);
  735. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_amount = 1;
  736. }
  737. else {
  738. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_id = realloc(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_id, sizeof(int)*(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_amount+1));
  739. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_amount++;
  740. }
  741. // content id is assigned the bind index, this should not be the case as the bind index is symbolic to the argv_id index
  742. // instead content_id is assigned to the current action code index reference
  744. action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_id[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_amount-1] =
  746. action_code_builder_struct[action_code_builder_struct->instances-1].references->content->instances-1
  748. ;
  750. printf("action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[%d].bind_index (%d)].content_amount = %d\n", ii, action_code_binder[ii].bind_index, action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_amount);
  752. for (int iii = 0; iii < action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_amount; iii++) {
  754. printf("action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[%d].bind_index (%d)].content_id[%d] = %d\n", ii, action_code_binder[ii].bind_index, iii, action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[action_code_binder[ii].bind_index].content_id[iii]);
  755. }
  756. }
  757. env__free(index_check);
  758. index_check = NULL;
  759. }
  760. }
  761. if (has_contents) {
  762. for (i = 0; i < d; i++) { printf(" "); }
  763. printf("tag: '%s', contents: '%s'\n", a->tag, a->contents);
  764. }
  765. else {
  766. for (i = 0; i < d; i++) { printf(" "); }
  767. printf("tag: '%s'\n", a->tag);
  768. }
  769. }
  770. else if (has_contents) {
  771. for (i = 0; i < d; i++) { printf(" "); }
  772. printf("contents: '%s'\n", a->contents);
  773. }
  774. }
  775. for (i = 0; i < a->children_num; i++) {
  776. Build_Action_Code_Structure(a->children[i], d+1, is_sub_contents_part_of_action, false);
  777. }
  778. }
  780. int number_ifs = 0;
  781. mpc_ast_t *ra = NULL;
  782. int instructions = 0;
  783. mpc_ast_t *prev;
  784. bool isimportant = false;
  786. int tag_index = 0;
  787. bool has_action_structures = false;
  789. void find_instructions(mpc_ast_t *a, mpc_ast_t *orig, int d, bool is_sub_contents_part_of_instruction, bool is_sub_contents_part_of_sub_rule, bool is_sub_contents_part_of_action) {
  790. int i;
  791. if (a == NULL) {
  792. printf("NULL\n");
  793. return;
  794. }
  796. bool is_end = false;
  797. if (strcmp(a->tag, "instruction_end|>") == 0 || strcmp(a->tag, "instruction_end|EOL|string") == 0) is_end = true;
  799. bool is_an_action = false;
  800. bool is_an_action_structure = false;
  801. bool is_an_action_segmented_structure = false;
  803. if (strcmp(a->tag, "action|>") == 0) is_an_action = true;
  804. else if (strcmp(a->tag, "action_code|>") == 0) is_an_action_structure = true;
  805. else if (strcmp(a->tag, "action_code_segmented|>") == 0) is_an_action_segmented_structure = true;
  807. if (is_an_action_segmented_structure == true || is_an_action_structure == true) is_sub_contents_part_of_action = true;
  809. if (strcmp(a->tag, "root|instruction|>") == 0 || strcmp(a->tag, "instruction|>") == 0) {
  810. tag_index = 0;
  811. is_sub_contents_part_of_instruction = true;
  812. ra = a;
  813. int matches = 0;
  814. has_action_structures = false;
  815. puts("initiating quick search for code structures");
  816. Build_Action_Code_Structure_Quick_Scan(a, &matches);
  817. puts("quick search COMPLETE");
  818. if (matches != 0) {
  819. has_action_structures = true;
  820. puts("code structures detected\ninitiating full search for code structures");
  821. Build_Action_Code_Structure(a, 0, false, true);
  822. puts("full search complete");
  823. puts("PRINTING ARGUMENT LIST");
  824. printf("action_code_builder_struct[%d].references->argc = %d\n", action_code_builder_struct->instances, action_code_builder_struct[action_code_builder_struct->instances-1].references->argc);
  825. for(int i = 0; i < action_code_builder_struct[action_code_builder_struct->instances-1].references->argc; i++) {
  826. printf("action_code_builder_struct[%d].references->argv[%d] = %s\n", action_code_builder_struct->instances, i, action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[i]);
  827. }
  828. puts("PRINTED ARGUMENT LIST");
  829. } else puts("no code structures detected");
  830. } else if (strcmp(a->tag, "root|definition|>") == 0 || strcmp(a->tag, "root|>") == 0) {
  831. is_sub_contents_part_of_instruction = false;
  832. }
  835. if (is_sub_contents_part_of_instruction == true) {
  836. for (i = 0; i < d; i++) printf(" ");
  837. if (is_end == true) {
  838. printf("tag: '%s', contents: '%s'\n", a->tag, a->contents);
  839. pi(number_ifs)
  840. while(number_ifs != 0) {
  841. number_ifs--;
  842. str_new(tmp);
  843. pi(number_ifs)
  844. if (number_ifs != 0) { str_insert_string(tmp, "} else read__string_undo(binstr.data);\n"); }
  845. else str_insert_string(tmp, "}");
  846. str_output_append(tmp.indented, outfile);
  847. str_free(tmp);
  848. }
  849. }
  850. else {
  851. if (strlen(a->contents)) {
  852. printf("tag: '%s', contents: '%s'\n", a->tag, a->contents);
  853. if (strcmp(a->tag, "binary|regex") == 0) {
  854. if (number_ifs == 0) instructions++;
  855. number_ifs++;
  856. str_new(tmp);
  857. if (instructions > 1 && number_ifs == 1) {
  858. str_insert_string(tmp, " else ");
  859. }
  860. else {
  861. str_insert_string(tmp, "\n");
  862. }
  863. str_insert_string(tmp, "if (!");
  864. str_insert_string(tmp, "regexEngineb(");
  865. str_insert_int(tmp, strlen(a->contents));
  866. str_insert_string(tmp, ", ");
  867. str_insert_int(tmp, strlen(a->contents));
  868. str_insert_string(tmp, ", \"");
  869. if (strlen(a->contents) != 1) {
  870. str_insert_int(tmp, strlen(a->contents)-1);
  871. str_insert_string(tmp, "-");
  872. }
  873. str_insert_string(tmp, "0,");
  874. str_insert_string(tmp, a->contents);
  875. str_insert_string(tmp, "\", binstr.data, ");
  876. if (instructions >1 && number_ifs == 1) { str_insert_string(tmp, "true"); }
  877. else { str_insert_string(tmp, "false"); }
  878. str_insert_string(tmp, ")");
  879. str_insert_string(tmp, ") {");
  880. // str_insert_string(tmp, "printf(\"a->contents = ");
  881. // str_insert_string(tmp, a->contents);
  882. // str_insert_string(tmp, ", regexEngineb_bits = %s\\n\", regexEngineb_bits);\n");
  883. str_output_append(tmp.indented, outfile);
  884. str_free(tmp);
  885. if (number_ifs == 1) find_instruction_root(ra);
  886. }
  887. if (strcmp(a->tag, "ISA_RULE|word|regex") == 0 || (strcmp(a->tag, "word|regex") == 0 && is_sub_contents_part_of_sub_rule == true)) {
  888. puts("FINDING");
  889. find_definition_root(orig, a->contents);
  890. puts("FOUND");
  891. }
  892. if (strcmp(a->tag, "ISA_DEFINE|word|regex") == 0 || strcmp(a->tag, "ISA_RULE|word|regex") == 0 || strcmp(a->tag, "word|regex") == 0 || strcmp(a->tag, "binary|regex") == 0) {
  893. if (is_sub_contents_part_of_action == false && has_action_structures) {
  894. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_amount)
  895. if (action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_amount) {
  896. for (int i = 0; i < action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_amount; i++) {
  897. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_id[i]].content.string);
  898. str_output_append(action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_id[i]].content.indented, outfile);
  899. }
  900. /* ps(a->contents); // contains current argv string
  901. pi(tag_index);
  902. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref->instances);
  903. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[tag_index]);
  904. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].argv_id);
  905. pp(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[0].content_id)
  906. // pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[0].content_id[0]);
  907. pp(action_code_builder_struct[action_code_builder_struct->instances-1].references->content->content.string);
  908. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->content->content.string);
  909. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_id[0]);
  910. pp(action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_id[0]])
  911. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_amount);
  912. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->content[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].content_id[0]].content.string);
  913. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->argc);
  914. ps(action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].argv_id]);
  915. pi(action_code_builder_struct[action_code_builder_struct->instances-1].references->ref[tag_index].occurence_number);
  916. */ if (strcmp(a->contents, action_code_builder_struct[action_code_builder_struct->instances-1].references->argv[tag_index]) != 0) {
  917. puts("INCONSISTANCY DETECTED");
  918. abort();
  919. };
  920. }
  921. tag_index++;
  922. }
  923. }
  924. } else {
  925. printf("tag: '%s'\n", a->tag);
  926. if (strcmp(a->tag, "ISA_RULE|>") == 0) is_sub_contents_part_of_sub_rule = true;
  927. if(is_an_action) {
  928. str_new(tmp);
  929. aquire_action_code(a, &tmp);
  930. ps(tmp.string);
  931. str_output_append(tmp.indented, outfile);
  932. str_free(tmp);
  933. }
  934. }
  935. }
  936. }
  937. prev = a;
  938. if (
  939. is_an_action == false &&
  940. is_an_action_structure == false &&
  941. is_an_action_segmented_structure == false
  942. ) for (i = 0; i < a->children_num; i++) {
  943. find_instructions(a->children[i], orig, d+1, is_sub_contents_part_of_instruction, is_sub_contents_part_of_sub_rule, is_sub_contents_part_of_action);
  944. }
  945. }
  947. void evalfile(char * string, mpc_parser_t *p, mpc_result_t * r) {
  948. if (mpc_parse_contents(string, p, r)) { // parse file specified in string with parser p and store resulting AST into r->output
  949. AP(r->output, 0, stdout); // prints full AST
  950. mpc_ast_delete(r->output);
  951. } else {
  952. mpc_err_print(r->error);
  953. mpc_err_delete(r->error);
  954. }
  955. }
  957. void evalfileI(char * string, mpc_parser_t *p, mpc_result_t * r) {
  958. if (mpc_parse_contents(string, p, r)) { // parse file specified in string with parser p and store resulting AST into r->output
  959. instructions = 0;
  960. find_instructions(r->output, r->output, 0, false, false, false); // attempts to print instruction part of ast with definition replacement done in instructions
  961. mpc_ast_delete(r->output);
  962. } else {
  963. mpc_err_print(r->error);
  964. mpc_err_delete(r->error);
  965. }
  966. }
  968. void eval(char * string, mpc_parser_t *p, mpc_result_t * r) {
  969. if (mpc_parse("test", string, p, r)) {
  970. mpc_ast_print(r->output);
  971. mpc_ast_delete(r->output);
  972. } else {
  973. mpc_err_print(r->error);
  974. mpc_err_delete(r->error);
  975. }
  976. }
  978. #define mpcnew(x) mpc_parser_t * x = mpc_new(#x)
  980. int main(int argc, char **argv) {
  981. mpcnew(parser_root);
  982. mpcnew(root);
  983. mpcnew(definition);
  984. mpcnew(instruction);
  985. mpcnew(definition_start);
  986. mpcnew(definition_statement);
  987. mpcnew(definition_item);
  988. mpcnew(instruction_start);
  989. mpcnew(instruction_statement);
  990. mpcnew(instruction_item);
  991. mpcnew(instruction_end);
  992. mpcnew(EOL);
  993. mpcnew(hash);
  994. mpcnew(ISA_DEFINE);
  995. mpcnew(colon);
  996. mpcnew(ha_statement);
  997. mpcnew(item);
  998. mpcnew(bracketed_item);
  999. mpcnew(normal_item);
  1000. mpcnew(pair);
  1001. mpcnew(single);
  1002. mpcnew(S);
  1003. mpcnew(space);
  1004. mpcnew(tab);
  1005. mpcnew(word);
  1006. mpcnew(binary);
  1007. mpcnew(ISA_RULE);
  1008. mpcnew(comma);
  1009. mpcnew(comment);
  1010. mpcnew(single_line_comment);
  1011. mpcnew(multi_line_comment);
  1013. mpcnew(action_code);
  1014. mpcnew(name);
  1015. mpcnew(num);
  1016. mpcnew(indexedname);
  1017. mpcnew(number);
  1020. mpcnew(word_segmented);
  1021. mpcnew(number_segmented);
  1022. mpcnew(action_code_segmented);
  1023. mpcnew(name_segmented);
  1024. mpcnew(num_segmented);
  1025. mpcnew(indexedname_segmented);
  1026. mpcnew(SS);
  1027. mpcnew(action);
  1028. mpc_err_t* err = mpca_lang_contents(MPCA_LANG_WHITESPACE_SENSITIVE, "grammer_parser.parse", parser_root, root, definition, instruction, definition_start, definition_statement, definition_item, instruction_start, instruction_statement, instruction_item, instruction_end, item, bracketed_item, normal_item, single, pair, hash, colon, word, binary, ISA_RULE, ISA_DEFINE, EOL, S, space, tab, comma, comment, single_line_comment, multi_line_comment, action_code, name, num, indexedname, number, action_code_segmented, name_segmented, num_segmented, indexedname_segmented, number_segmented, word_segmented, SS, action);
  1029. if (err != NULL) {
  1030. mpc_err_print(err);
  1031. mpc_err_delete(err);
  1032. exit(1);
  1033. }
  1034. mpc_result_t r;
  1035. STR_INDENT_LEVEL = 0;
  1036. STR_INDENT_SIZE = 8;
  1037. str_new(ff);
  1038. str_include(ff, "ISA_test_PRE.c");
  1039. str_output(ff, outfile);
  1040. // evalfile("Intel4004TEST.isa", parser_root, &r);
  1041. evalfile("Intel4004.isa", parser_root, &r);
  1042. // evalfileI("Intel4004.isa", parser_root, &r);
  1043. str_reset(ff);
  1044. str_insert_string(ff, "}");
  1045. str_output_append(ff.indented, outfile);
  1046. str_free(ff);
  1047. // mpc_parser_t * re = mpc_new("re");
  1048. // mpc_define(re, mpc_re("(ab(cd))+"));
  1049. // mpc_result_t rr;
  1050. // if (mpc_parse("test", "abcd", re, &rr)) {
  1051. // puts("passed");
  1052. // ps(rr.output)
  1053. // } else {
  1054. // puts("failed");
  1055. // mpc_err_print(rr.error);
  1056. // mpc_err_delete(rr.error);
  1057. // }
  1058. return 0;
  1059. }
  1060.  
Powered by spacepaste. Paste removal.