spacepaste

Paste details

reply | raw

  1.  
  2. $ cat ./undo_history.c
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <inttypes.h>
  7. // A C program to demonstrate linked list based implementation of queue
  8. // A linked list (LL) node to store a queue entry
  9. struct QNode
  10. {
  11. int16_t type;
  12. struct QNode *next;
  13. };
  15. // The queue, front stores the front node of LL and rear stores ths
  16. // last node of LL
  17. struct Queue
  18. {
  19. struct QNode *front, *rear;
  20. };
  22. // A utility function to create a new linked list node.
  23. struct QNode* newNode(int16_t type)
  24. {
  25. struct QNode *temp = (struct QNode*)malloc(sizeof(struct QNode));
  26. temp->type = type;
  27. temp->next = NULL;
  28. return temp;
  29. }
  31. // A utility function to create an empty queue
  32. struct Queue *createQueue()
  33. {
  34. struct Queue *q = (struct Queue*)malloc(sizeof(struct Queue));
  35. q->front = q->rear = NULL;
  36. return q;
  37. }
  39. void store_asm(struct Queue **qq, int16_t type)
  40. {
  41. if (*qq == NULL)
  42. *qq = createQueue();
  44. // Create a new LL node
  45. struct QNode *temp = newNode(type);
  47. // If queue is empty, then new node is front and rear both
  48. if ((*qq)->rear == NULL)
  49. {
  50. (*qq)->front = (*qq)->rear = temp;
  51. return;
  52. }
  54. // Add the new node at the end of queue and change rear
  55. (*qq)->rear->next = temp;
  56. (*qq)->rear = temp;
  57. }
  59. struct QNode * load_asm(struct Queue **qq)
  60. {
  61. if ((*qq) == NULL)
  62. return NULL;
  64. // If queue is empty, return NULL.
  65. if ((*qq)->rear == NULL)
  66. return NULL;
  68. // Store previous front and move front one node ahead
  69. struct QNode *temp = (*qq)->rear;
  70. (*qq)->rear = (*qq)->rear->next;
  72. // If front becomes NULL, then change rear also as NULL
  73. if ((*qq)->rear == NULL)
  74. (*qq)->front = NULL;
  75. return temp;
  76. }
  78. int main(void) {
  79. struct Queue * history;
  80. history = NULL;
  81. store_asm(&history, 1);
  82. store_asm(&history, 2);
  83. store_asm(&history, 3);
  85. puts("attempting to list node history");
  86. // obtain the first added instruction
  87. struct QNode * node = malloc(1); // this gets freed anyway
  88. int nodes = 0;
  89. while (node != NULL) {
  90. // drain the list until empty
  91. free(node);
  92. node = load_asm(&history);
  93. printf("node %d = %p\n", nodes, node);
  94. if (node == NULL) break;
  95. if (node) {
  96. printf("node->type = 0x%02x\n", node->type);
  97. printf("node->type = %d\n", node->type);
  98. }
  99. nodes++;
  100. }
  101. if (nodes == 0) puts("i have no history");
  102. else puts("i have no nodes left in history");
  104. // should result in 3, 2, 1
  106. return 0;
  107. }
  109. $ gcc undo_history.c -o undo_history
  112. $ ./undo_history
  113. attempting to list node history
  114. node 0 = 0x5583a820e2c0
  115. node->type = 0x03
  116. node->type = 3
  117. node 1 = (nil)
  118. i have no nodes left in history
  119.  
Powered by spacepaste. Paste removal.