spacepaste

Paste details

reply | raw

  1.  
  2. $ ./new
  3. FOUND BRANCH START
  4. FOUND BRANCH START
  5. 0 -> 1 (data: 1)
  6. printing branches
  7. printing branch 0
  8. branch start
  9. branch choice start
  10. 1 -> 2 (data: 2)
  11. branch choice end
  12. NULL
  13. finished printing branch 0
  14. branch start
  15. printing branches
  16. printing branch 0
  17. branch choice start
  18. 1 -> 2 (data: 2)
  19. branch choice end
  20. NULL
  21. finished printing branch 0
  22. printing branch 1
  23. branch choice start
  24. 2 -> 3 (data: 8)
  25. branch choice end
  26. branch end
  27. 3 -> 4 (data: 13)
  28. NULL
  29. finished printing branch 1
  30. branch choice start
  31. printing branches
  32. printing branch 0
  33. 1 -> 2 (data: 2)
  34. branch choice end
  35. NULL
  36. finished printing branch 0
  37. 1 -> 2 (data: 2)
  38. printing branches
  39. printing branch 0
  40. branch choice end
  41. NULL
  42. finished printing branch 0
  43. branch choice end
  44. NULL
  45. printing previous
  46. NULL
  47. 3 -> 4 (data: 13)
  48. branch end
  49. branch choice end
  50. 2 -> 3 (data: 8)
  51. branch choice start
  52. branch choice end
  53. 1 -> 2 (data: 2)
  54. branch choice start
  55. branch start
  56. 0 -> 1 (data: 1)
  58. $ cat new.c
  59. #include <stdbool.h>
  60. #include <stdio.h>
  61. #include <stdlib.h>
  62. #include <string.h>
  64. #define pp(x) printf("%s = %p\n", #x, x);
  65. #define pi(x) printf("%s = %d\n", #x, x);
  66. #define pc(x) printf("%s = %c\n", #x, x);
  67. #define psize_t(x) printf("%s = %zu\n", #x, x);
  69. #define LINKED 1
  70. #define TREE 2
  71. #define NODE_TYPE TREE
  73. struct QNode
  74. {
  75. int level;
  76. int index;
  77. int ref;
  78. int data;
  79. int type;
  80. #if NODE_TYPE == LINKED
  81. struct QNode *next;
  82. #elif NODE_TYPE == TREE
  83. int next_count;
  84. struct QNode **next;
  85. #endif
  86. struct QNode* prev; // Pointer to previous node in DLL
  87. };
  89. // The queue, front stores the front node of LL and rear stores ths
  90. // last node of LL
  91. struct Queue
  92. {
  93. struct QNode *front, *rear;
  94. };
  96. ssize_t free_asm(struct Queue **q)
  97. {
  98. puts("");
  99. ssize_t frees = 0;
  100. if ((q) == NULL) return frees;
  101. if ((*q) == NULL) return frees;
  102. struct QNode *temp = NULL, *next = NULL;
  103. temp = (*q)->front;
  104. while (temp) {
  105. #if NODE_TYPE == LINKED
  106. next = (*q)->front->next;
  107. #elif NODE_TYPE == TREE
  108. // unknown, would use this
  109. /*
  110. if (node->next) {
  111. if (node->next[0]) {
  112. free(node->next[0]);
  113. nodes++;
  114. }
  115. free(node->next);
  116. nodes++;
  117. */
  118. next = (*q)->front->next[0];
  119. #endif
  120. frees++;
  121. free(temp);
  122. temp = NULL;
  123. (*q)->front = next;
  124. temp = next;
  125. }
  126. frees++;
  127. free(*q);
  128. *q = NULL;
  129. return frees;
  130. }
  133. // A C program to demonstrate linked list based implementation of queue
  134. // A linked list (LL) node to store a queue entry
  135. int index_start = -1;
  136. int ref_start = 0;
  137. int global_indent = 0;
  139. #if NODE_TYPE == LINKED
  140. #define node_init(t, i, r, d, n) t->index = i; t->ref = r; t->data = d; t->next = n; t->level = global_indent; t->prev = NULL;
  141. #elif NODE_TYPE == TREE
  142. #define node_init(t, i, r, d, nc, n) t->index = i; t->ref = r; t->data = d; t->next_count = nc; t->next = n; t->level = global_indent; t->prev = NULL;
  143. #endif
  145. #define STORE_NORMAL 1
  146. #define STORE_EMPTY 2
  148. #define NODE_TYPE_NORMAL 1
  149. #define NODE_TYPE_BRANCH_START 2
  150. #define NODE_TYPE_BRANCH_END 3
  151. #define NODE_TYPE_BRANCH_CHOICE_START 4
  152. #define NODE_TYPE_BRANCH_CHOICE_END 5
  154. #define POINTER_LIST_TYPE int
  156. POINTER_LIST_TYPE ** ptr_list = NULL;
  157. ssize_t ptr_list_size = 0;
  159. int last_ref = 0;
  161. int ptr_add(POINTER_LIST_TYPE * ptr) {
  162. if (!ptr) return -1;
  163. if (!ptr_list) {
  164. ptr_list = malloc(sizeof(*ptr_list)*2);
  165. ptr_list_size++;
  166. }
  167. else if (ptr_list) {
  168. ptr_list = realloc(ptr_list, sizeof(*ptr_list)*(ptr_list_size+1));
  169. }
  170. ptr_list[ptr_list_size-1] = ptr;
  171. ptr_list_size++;
  172. ptr_list[ptr_list_size-1] = NULL;
  173. return 0;
  174. }
  176. int ptr_print(void) {
  177. if (!ptr_list) return -1;
  178. POINTER_LIST_TYPE ** pl;
  179. for (pl = ptr_list; *pl; pl++) pp(*pl);
  180. return 0;
  181. }
  183. int ptr_set(POINTER_LIST_TYPE data) {
  184. if (!ptr_list) return -1;
  185. POINTER_LIST_TYPE ** pl;
  186. for (pl = ptr_list; *pl; pl++) **pl = data;
  187. return 0;
  188. }
  190. int ptr_set_free(void) {
  191. if (!ptr_list) return -1;
  192. POINTER_LIST_TYPE ** pl;
  193. for (pl = ptr_list; *pl; pl++) {
  194. free(*pl);
  195. *pl = NULL;
  196. }
  197. return 0;
  198. }
  200. int ptr_free(void) {
  201. if (!ptr_list) return -1;
  202. POINTER_LIST_TYPE ** pl;
  203. for (pl = ptr_list; *pl; pl++) *pl = NULL;
  204. free(ptr_list);
  205. ptr_list = NULL;
  206. ptr_list_size = 0;
  207. return 0;
  208. }
  210. // A utility function to create a new linked list node.
  211. struct QNode* newNode(int data, int type)
  212. {
  213. struct QNode *temp = (struct QNode*)malloc(sizeof(*temp));
  214. #if NODE_TYPE == LINKED
  215. if (type == STORE_NORMAL) {
  216. node_init(temp, index_start++, ref_start++, data, NULL);
  217. } else if (type == STORE_EMPTY) {
  218. node_init(temp, 0, 0, 0, NULL);
  219. }
  220. #elif NODE_TYPE == TREE
  221. if (type == STORE_NORMAL) {
  222. node_init(temp, index_start++, ref_start++, data, 0, NULL);
  223. } else if (type == STORE_EMPTY) {
  224. node_init(temp, 0, 0, 0, 0, NULL);
  225. }
  226. #endif
  227. return temp;
  228. }
  230. // A utility function to create an empty queue
  231. struct Queue *createQueue()
  232. {
  233. struct Queue *q = (struct Queue*)malloc(sizeof(*q));
  234. q->front = q->rear = NULL;
  235. return q;
  236. }
  237. int prev_type = 0;
  238. int curr_type = 0;
  239. void store_asm(struct Queue *q, int data, int type)
  240. {
  241. if (curr_type) prev_type = curr_type;
  242. curr_type = type;
  243. // Create a new LL node
  244. int t = 0;
  245. if (type == NODE_TYPE_NORMAL) t = STORE_NORMAL;
  246. else if (
  247. type == NODE_TYPE_BRANCH_START
  248. ||
  249. type == NODE_TYPE_BRANCH_END
  250. ||
  251. type == NODE_TYPE_BRANCH_CHOICE_START
  252. ||
  253. type == NODE_TYPE_BRANCH_CHOICE_END
  254. ) t = STORE_EMPTY;
  255. struct QNode *temp = newNode(data, t);
  256. temp->type = type;
  258. // If queue is empty, then new node is front and rear both
  259. if (q->rear == NULL)
  260. {
  261. temp->prev = NULL;
  262. q->front = q->rear = temp;
  263. return;
  264. }
  265. if (prev_type == NODE_TYPE_NORMAL) {
  267. if (type == NODE_TYPE_BRANCH_CHOICE_END) {
  268. // we reach a the end of a branch choice, add the address of the last reference, the pointer to the next node, to an array of pointers
  269. // last_ref = q->rear->ref;
  270. // printf("adding %d to the pointer list\n", last_ref);
  271. // ptr_add(&q->rear->ref);
  272. }
  273. }
  274. else if(type == NODE_TYPE_NORMAL && prev_type == NODE_TYPE_BRANCH_END) {
  275. // we reach a node and we where previously at a branch, set all referenced logged to the value of the current node reference, then we free the pointer list
  276. // printf("setting pointer list to %d\n", last_ref);
  277. // ptr_set(last_ref);
  278. // ptr_free();
  279. }
  280. // Add the new node at the end of queue and change rear
  282. temp->prev = q->rear;
  283. // allocate a new array for our new item
  284. #if NODE_TYPE == LINKED
  285. if (!q->rear->next) {
  286. q->rear->next = malloc(sizeof(*q->rear->next));
  287. } else {
  288. abort();
  289. }
  290. // update rear->next to point to the new item
  291. q->rear->next = temp;
  292. // update rear to point to the rear->next, which is the item we just added, updating the pointer rear from our old item to our new item
  293. q->rear = q->rear->next;
  294. #elif NODE_TYPE == TREE
  295. struct QNode * p = q->rear;
  296. if (type == NODE_TYPE_BRANCH_CHOICE_START) {
  297. while(p) {
  298. if (p->type == NODE_TYPE_BRANCH_START) {
  299. puts("FOUND BRANCH START");
  300. q->rear = p;
  301. break;
  302. }
  303. if (p->prev) p = p->prev;
  304. else p = NULL;
  305. }
  306. }
  307. // allocate a new array for our new item
  308. if (!q->rear->next) {
  309. q->rear->next_count = 1;
  310. q->rear->next = malloc(sizeof(struct QNode)*q->rear->next_count);
  311. } else {
  312. q->rear->next_count++;
  313. q->rear->next = realloc(q->rear->next, sizeof(struct QNode)*q->rear->next_count);
  314. }
  315. // update rear->next to point to the new item
  316. q->rear->next[q->rear->next_count-1] = temp;
  318. // update rear to point to the rear->next, which is the item we just added, updating the pointer rear from our old item to our new item
  319. q->rear = q->rear->next[q->rear->next_count-1];
  320. #endif
  321. }
  323. struct QNode * load_asm(struct Queue **q)
  324. {
  325. // If queue is empty, return NULL.
  326. if ((q) == NULL) return NULL;
  327. if ((*q) == NULL) return NULL;
  328. if ((*q)->front == NULL)
  329. return NULL;
  331. // Store previous front and move front one node ahead
  332. struct QNode *temp = (*q)->front;
  333. // check if front->next is NULL, if NULL it means we have reached the end of the queue
  334. #if NODE_TYPE == LINKED
  335. (*q)->front = (*q)->front->next;
  336. #elif NODE_TYPE == TREE
  337. if ((*q)->front->next) (*q)->front = (*q)->front->next[0];
  338. else (*q)->front = NULL;
  339. #endif
  340. // If front becomes NULL, then change rear also as NULL
  341. if ((*q)->front == NULL)
  342. (*q)->rear = NULL;
  343. return temp;
  344. }
  346. #define add_indent(indent) { int i = 0; for (; i < indent; i++) printf(" "); }
  348. struct Queue * list = NULL;
  350. void printnode(struct QNode * p) {
  351. int indentation = p->level;
  352. add_indent(indentation);
  353. if (p->type == NODE_TYPE_BRANCH_START) {
  354. add_indent(indentation);
  355. printf("branch start\n");
  356. }
  357. else if (p->type == NODE_TYPE_BRANCH_END) {
  358. add_indent(indentation);
  359. printf("branch end\n");
  360. }
  361. else if (p->type == NODE_TYPE_BRANCH_CHOICE_START) {
  362. add_indent(indentation);
  363. printf("branch choice start\n");
  364. }
  365. else if (p->type == NODE_TYPE_BRANCH_CHOICE_END) {
  366. add_indent(indentation);
  367. printf("branch choice end\n");
  368. }
  369. else if (p->type == NODE_TYPE_NORMAL) {
  370. add_indent(indentation);
  371. printf("%d -> %d (data: %d)\n", p->index, p->ref, p->data);
  372. }
  373. #if NODE_TYPE == TREE
  374. // pi(p->next_count)
  375. #endif
  376. }
  378. void print_prev(struct QNode * p) {
  379. puts("NULL");
  380. while(p) {
  381. printnode(p);
  382. if (p->prev) p = p->prev;
  383. else p = NULL;
  384. }
  385. }
  387. void print_(struct QNode * p) {
  388. while(p) {
  389. printnode(p);
  390. #if NODE_TYPE == LINKED
  391. p = p->next;
  392. #elif NODE_TYPE == TREE
  393. if (p->next) p = p->next[0];
  394. else p = NULL;
  395. #endif
  396. }
  397. puts("NULL");
  398. }
  400. void print(struct QNode * p) {
  401. while(p) {
  402. printnode(p);
  403. #if NODE_TYPE == LINKED
  404. p = p->next;
  405. #elif NODE_TYPE == TREE
  406. if (p->next_count) {
  407. puts("printing branches");
  408. for (int i = 0; i < p->next_count; i++) {
  409. printf("printing branch %d\n", i);
  410. print_(p->next[i]);
  411. printf("finished printing branch %d\n", i);
  412. }
  413. }
  414. if (p->next) p = p->next[0];
  415. else p = NULL;
  416. #endif
  417. }
  418. puts("NULL");
  419. }
  421. void fix(struct Queue *p);
  423. void add(struct Queue **q, int data) {
  424. if (!(*q)) (*q) = createQueue();
  425. store_asm((*q), data, NODE_TYPE_NORMAL);
  426. }
  428. void add_branch(struct Queue **q) {
  429. if (!(*q)) (*q) = createQueue();
  430. store_asm((*q), 0, NODE_TYPE_BRANCH_START);
  431. global_indent++;
  432. }
  434. void end_branch(struct Queue **q) {
  435. global_indent--;
  436. if (!(*q)) (*q) = createQueue();
  437. store_asm((*q), 0, NODE_TYPE_BRANCH_END);
  438. }
  440. void add_branch_choice(struct Queue **q) {
  441. if (!(*q)) (*q) = createQueue();
  442. store_asm((*q), 0, NODE_TYPE_BRANCH_CHOICE_START);
  443. global_indent++;
  444. }
  446. void end_branch_choice(struct Queue **q) {
  447. global_indent--;
  448. if (!(*q)) (*q) = createQueue();
  449. // if we have a branch_end, we need to go backwards in out linked list to the node that came before the branch start
  450. store_asm((*q), 0, NODE_TYPE_BRANCH_CHOICE_END);
  451. }
  453. int main(void) {
  454. index_start = 0;
  455. ref_start = 1;
  457. /* attempt to visualize this in a expression grammar
  458. root ::= 0 A 61
  459. A ::=
  460. 1 2 B
  461. 5 6 C
  462. B ::=
  463. 3 4
  464. C ::=
  465. 7 8 D
  466. D ::=
  467. 9 10 F R
  468. 57 58 S
  469. F ::=
  470. G 41 42 P 45 46 47
  471. 48 49 Q 52 53 54
  472. G ::=
  473. 11 12 H
  474. 15 16 I
  475. H ::=
  476. 13 14
  477. I ::=
  478. 17 18 J
  479. J ::=
  480. 19 20 K N
  481. 37 38 O
  482. K ::=
  483. 21 22 L 25 26 27
  484. 28 29 M 32 33 34
  485. L ::=
  486. 23 24
  487. M ::=
  488. 30 31
  489. N ::=
  490. 35 36
  491. O ::=
  492. 39 40
  493. P ::=
  494. 43 44
  495. Q ::=
  496. 50 51
  497. R ::=
  498. 55 56
  499. S ::=
  500. 59 60
  502. structure:
  504. root: 0 A 61 > NULL
  505. A: 1 2 B
  506. B: 3 4 > 61 // currently 4 > 25
  507. A: 5 6 C
  508. C: 7 8 D
  509. D: 9 10 F R
  510. F: G 41 42 P 45 46 47 > 55 (R) // currently 47 > 52
  511. G: 11 12 H
  512. H: 13 14 > 41 // currently 14 > 25
  513. G: 15 16 I
  514. I: 16 18 J
  515. J: 19 20 K N
  516. K: 21 22 L 25 26 27 > 35 (N) // currently 27 > 32
  517. L: 23 24 > 25
  518. K: 28 29 M 32 33 34 > 35 (N)
  519. M: 30 31 > 32
  520. N: 35 36 > 41
  521. J: 37 38 O
  522. O: 39 40 > 41
  523. P: 43 44 > 45
  524. F: 48 49 Q 52 53 54 > 55 (R)
  525. Q: 50 51 > 52
  526. R: 55 56 > 61
  527. D: 57 58 S
  528. S: 59 60 > 61
  529. add(&list, 1);
  530. add_branch(&list);
  531. add_branch_choice(&list);
  532. add(&list, 2);
  533. add(&list, 3);
  534. add_branch(&list);
  535. add_branch_choice(&list);
  536. add(&list, 4);
  537. add(&list, 5);
  538. end_branch_choice(&list);
  539. end_branch(&list);
  540. end_branch_choice(&list);
  541. add_branch_choice(&list);
  542. add(&list, 6);
  543. add(&list, 7);
  544. add_branch(&list);
  545. add_branch_choice(&list);
  546. add(&list, 8);
  547. add(&list, 9);
  548. add_branch(&list);
  549. add_branch_choice(&list);
  550. add(&list, 10);
  551. add(&list, 11);
  552. add_branch(&list);
  553. add_branch_choice(&list);
  554. add_branch(&list);
  555. add_branch_choice(&list);
  556. add(&list, 12);
  557. add(&list, 13);
  558. add_branch(&list);
  559. add_branch_choice(&list);
  560. add(&list, 14);
  561. add(&list, 15);
  562. end_branch_choice(&list);
  563. end_branch(&list);
  564. end_branch_choice(&list);
  565. add_branch_choice(&list);
  566. add(&list, 16);
  567. add(&list, 17);
  568. add_branch(&list);
  569. add_branch_choice(&list);
  570. add(&list, 18);
  571. add(&list, 19);
  572. add_branch(&list);
  573. add_branch_choice(&list);
  574. add(&list, 20);
  575. add(&list, 21);
  576. add_branch(&list);
  577. add_branch_choice(&list);
  578. add(&list, 22);
  579. add(&list, 23);
  580. add_branch(&list);
  581. add_branch_choice(&list);
  582. add(&list, 24);
  583. add(&list, 25);
  584. end_branch_choice(&list);
  585. end_branch(&list);
  586. add(&list, 26);
  587. add(&list, 27);
  588. add(&list, 28);
  589. end_branch_choice(&list);
  590. add_branch_choice(&list);
  591. add(&list, 29);
  592. add(&list, 30);
  593. add_branch(&list);
  594. add_branch_choice(&list);
  595. add(&list, 31);
  596. add(&list, 32);
  597. end_branch_choice(&list);
  598. end_branch(&list);
  599. add(&list, 33);
  600. add(&list, 34);
  601. add(&list, 35);
  602. end_branch_choice(&list);
  603. end_branch(&list);
  604. add_branch(&list);
  605. add_branch_choice(&list);
  606. add(&list, 36);
  607. add(&list, 37);
  608. end_branch_choice(&list);
  609. end_branch(&list);
  610. end_branch_choice(&list);
  611. add_branch_choice(&list);
  612. add(&list, 38);
  613. add(&list, 39);
  614. add_branch(&list);
  615. add_branch_choice(&list);
  616. add(&list, 40);
  617. add(&list, 41);
  618. end_branch_choice(&list);
  619. end_branch(&list);
  620. end_branch_choice(&list);
  621. end_branch(&list);
  622. end_branch_choice(&list);
  623. end_branch(&list);
  624. end_branch_choice(&list);
  625. end_branch(&list);
  626. add(&list, 42);
  627. add(&list, 43);
  628. add_branch(&list);
  629. add_branch_choice(&list);
  630. add(&list, 44);
  631. add(&list, 45);
  632. end_branch_choice(&list);
  633. end_branch(&list);
  634. add(&list, 46);
  635. add(&list, 47);
  636. add(&list, 48);
  637. end_branch_choice(&list);
  638. add_branch_choice(&list);
  639. add(&list, 49);
  640. add(&list, 50);
  641. add_branch(&list);
  642. add_branch_choice(&list);
  643. add(&list, 51);
  644. add(&list, 52);
  645. end_branch_choice(&list);
  646. end_branch(&list);
  647. add(&list, 53);
  648. add(&list, 54);
  649. add(&list, 55);
  650. end_branch_choice(&list);
  651. end_branch(&list);
  652. add_branch(&list);
  653. add_branch_choice(&list);
  654. add(&list, 56);
  655. add(&list, 57);
  656. end_branch_choice(&list);
  657. end_branch(&list);
  658. end_branch_choice(&list);
  659. add_branch_choice(&list);
  660. add(&list, 58);
  661. add(&list, 59);
  662. add_branch(&list);
  663. add_branch_choice(&list);
  664. add(&list, 60);
  665. add(&list, 61);
  666. end_branch_choice(&list);
  667. end_branch(&list);
  668. end_branch_choice(&list);
  669. end_branch(&list);
  670. end_branch_choice(&list);
  671. end_branch(&list);
  672. end_branch_choice(&list);
  673. end_branch(&list);
  674. add(&list, 62);
  675. */
  679. /* attempt to visualize this in a expression grammar
  680. root ::= 1 A 13
  681. A ::=
  682. 2 3 B 6
  683. 7 8 C
  684. B ::=
  685. 4
  686. C ::=
  687. 9 10 D
  688. D ::=
  689. 11
  691. structure:
  693. root: 1 A 13 > NULL
  694. A: 2 3 B 6 > 13
  695. B: 4 5 > 6
  696. A: 7 8 C
  697. C: 9 10 D
  698. D: 11 > 13
  699. */
  700. add(&list, 1);
  701. add_branch(&list);
  702. add_branch_choice(&list);
  703. add(&list, 2);
  704. // add(&list, 3);
  705. // add_branch(&list);
  706. // add_branch_choice(&list);
  707. // add(&list, 4);
  708. // add(&list, 5);
  709. // end_branch_choice(&list);
  710. // end_branch(&list);
  711. // add(&list, 6);
  712. end_branch_choice(&list);
  713. add_branch_choice(&list);
  714. // add(&list, 7);
  715. add(&list, 8);
  716. // add_branch(&list);
  717. // add_branch_choice(&list);
  718. // add(&list, 9);
  719. // add(&list, 10);
  720. // add_branch(&list);
  721. // add_branch_choice(&list);
  722. // add(&list, 11);
  723. // add(&list, 12);
  724. // end_branch_choice(&list);
  725. // end_branch(&list);
  726. // end_branch_choice(&list);
  727. // end_branch(&list);
  728. end_branch_choice(&list);
  729. end_branch(&list);
  730. add(&list, 13);
  731. print(list->front);
  732. puts("printing previous");
  733. print_prev(list->rear);
  735. // fix(list);
  736. // this part should be left to the garbage collector to clean up
  737. #if NODE_TYPE == LINKED
  738. psize_t(free_asm(&list));
  739. #endif
  740. return 0;
  741. }
  743. void print_indentation(struct QNode * p, int indentation) {
  744. printf("printing nodes with an indentation level of %d\n", indentation);
  745. while(p) {
  746. if (p->level == indentation) {
  747. add_indent(indentation);
  748. if (p->type == NODE_TYPE_BRANCH_START) {
  749. add_indent(indentation);
  750. printf("branch start\n");
  751. }
  752. else if (p->type == NODE_TYPE_BRANCH_END) {
  753. add_indent(indentation);
  754. printf("branch end\n");
  755. }
  756. else if (p->type == NODE_TYPE_BRANCH_CHOICE_START) {
  757. add_indent(indentation);
  758. printf("branch choice start\n");
  759. }
  760. else if (p->type == NODE_TYPE_BRANCH_CHOICE_END) {
  761. add_indent(indentation);
  762. printf("branch choice end\n");
  763. }
  764. else if (p->type == NODE_TYPE_NORMAL) {
  765. add_indent(indentation);
  766. printf("%d -> %d (data: %d)\n", p->index, p->ref, p->data);
  767. }
  768. }
  769. #if NODE_TYPE == LINKED
  770. p = p->next;
  771. #elif NODE_TYPE == TREE
  772. if (p->next) p = p->next[0];
  773. else p = NULL;
  774. #endif
  775. }
  776. }
  778. void fix(struct Queue * list) {
  779. int indent = 0;
  780. print_indentation(list->front, indent++);
  781. print_indentation(list->front, indent++);
  782. print_indentation(list->front, indent++);
  783. print_indentation(list->front, indent++);
  784. print_indentation(list->front, indent++);
  785. puts("NULL");
  786. }
  787.  
Powered by spacepaste. Paste removal.