Language: C

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>


struct queue_tag {
  uint8_t *data;
  size_t size;
  size_t top;
  size_t buttom;
  size_t max_size;
};

queue_t *queue_create(const size_t len)
{
  queue_t *q = (queue_t *)malloc(sizeof(queue_t));
  if (q == NULL) goto err;

  q->data = (uint8_t *)malloc(len);
  if (q->data == NULL) goto err;

  q->size = 0;
  q->top = 0;
  q->buttom = 0;
  q->max_size = len;

  return q;

err:
  perror("memeory is full\n");
  exit(1);
}

void queue_destroy(queue_t *const q)
{
  if (q != NULL) {
    free(q->data);
  }
  free(q);

  return;
}

size_t queue_get_size(const queue_t *const q)
{
  if (q == NULL) {
    return 0;
  }

  return q->size;
}

static bool enqueue_check_params(queue_t *const q, size_t len)
{
  if (q == NULL) return false;

  if (q->max_size < len) return false;

  if (q->max_size < (q->size + len)) return false;

  return true;
}

bool queue_enqueue(queue_t *const q, void *data, size_t len)
{
  if (!enqueue_check_params(q, len)) {
    return false;
  }

  for (uint32_t i = 0; i < len; i++) {
    q->data[q->top++] = ((uint8_t *)data)[i];
    q->top %= q->max_size;
    q->size++;
  }

  return true;
}

static bool dequeue_check_params(queue_t *const q, size_t len)
{
  if (q == NULL) return false;

  if ((int32_t)((int32_t)q->size - len) < 0) return false;

  return true;
}

bool queue_dequeue(queue_t *const q, void *data, size_t len)
{
  if (!dequeue_check_params(q, len)) {
    return false;
  }

  for (uint32_t i = 0; i < len; i++) {
    ((uint8_t *)data)[i] = q->data[q->buttom++];
    q->buttom %= q->max_size;
    q->size--;
  }

  return true;
}

#if !defined(TEST)
typedef struct {
  char name[16];
  int32_t time;
} process_t;

int32_t main(void)
{
  int32_t num = 0;
  int32_t quantum = 0;
  scanf("%d %d", &num, &quantum);

  queue_t *q = queue_create(sizeof(process_t) * 256 * 1000);

  int32_t i;
  for (i = 0; i < num; i++) {
    process_t process;
    scanf("%s %d", process.name, &process.time);
    queue_enqueue(q, (void *)&process, sizeof(process));
  }

  int32_t elapsed = 0;
  while (queue_get_size(q)) {
    process_t process;
    queue_dequeue(q, (void *)&process, sizeof(process));
    if ((process.time - quantum) <= 0) {
      elapsed += process.time;
      printf("%s %d\n", process.name, elapsed);
    } else {
      process.time -= quantum;
      queue_enqueue(q, (void *)&process, sizeof(process));
      elapsed += quantum;
    }
  }
  queue_destroy(q);
  return 0;
}
#endif

Compiler output:
main.c:14:1: error: unknown type name 'queue_t'
   14 | queue_t *queue_create(const size_t len)
      | ^~~~~~~
main.c: In function 'queue_create':
main.c:16:3: error: unknown type name 'queue_t'
   16 |   queue_t *q = (queue_t *)malloc(sizeof(queue_t));
      |   ^~~~~~~
main.c:16:17: error: 'queue_t' undeclared (first use in this function); did you mean 'queue_tag'?
   16 |   queue_t *q = (queue_t *)malloc(sizeof(queue_t));
      |                 ^~~~~~~
      |                 queue_tag
main.c:16:17: note: each undeclared identifier is reported only once for each function it appears in
main.c:16:26: error: expected expression before ')' token
   16 |   queue_t *q = (queue_t *)malloc(sizeof(queue_t));
      |                          ^
main.c:19:4: error: request for member 'data' in something not a structure or union
   19 |   q->data = (uint8_t *)malloc(len);
      |    ^~
main.c:20:8: error: request for member 'data' in something not a structure or union
   20 |   if (q->data == NULL) goto err;
      |        ^~
main.c:22:4: error: request for member 'size' in something not a structure or union
   22 |   q->size = 0;
      |    ^~
main.c:23:4: error: request for member 'top' in something not a structure or union
   23 |   q->top = 0;
      |    ^~
main.c:24:4: error: request for member 'buttom' in something not a structure or union
   24 |   q->buttom = 0;
      |    ^~
main.c:25:4: error: request for member 'max_size' in something not a structure or union
   25 |   q->max_size = len;
      |    ^~
main.c: At top level:
main.c:34:20: error: unknown type name 'queue_t'
   34 | void queue_destroy(queue_t *const q)
      |                    ^~~~~~~
main.c:44:29: error: unknown type name 'queue_t'
   44 | size_t queue_get_size(const queue_t *const q)
      |                             ^~~~~~~
main.c: In function 'queue_get_size':
main.c:50:11: error: request for member 'size' in something not a structure or union
   50 |   return q->size;
      |           ^~
main.c: At top level:
main.c:53:8: error: unknown type name 'bool'
   53 | static bool enqueue_check_params(queue_t *const q, size_t len)
      |        ^~~~
main.c:4:1: note: 'bool' is defined in header '<stdbool.h>'; this is probably fixable by adding '#include <stdbool.h>'
    3 | #include <stdlib.h>
  +++ |+#include <stdbool.h>
    4 | 
main.c:53:34: error: unknown type name 'queue_t'
   53 | static bool enqueue_check_params(queue_t *const q, size_t len)
      |                                  ^~~~~~~
main.c:64:1: error: unknown type name 'bool'
   64 | bool queue_enqueue(queue_t *const q, void *data, size_t len)
      | ^~~~
main.c:64:1: note: 'bool' is defined in header '<stdbool.h>'; this is probably fixable by adding '#include <stdbool.h>'
main.c:64:20: error: unknown type name 'queue_t'
   64 | bool queue_enqueue(queue_t *const q, void *data, size_t len)
      |                    ^~~~~~~
main.c:79:8: error: unknown type name 'bool'
   79 | static bool dequeue_check_params(queue_t *const q, size_t len)
      |        ^~~~
main.c:79:8: note: 'bool' is defined in header '<stdbool.h>'; this is probably fixable by adding '#include <stdbool.h>'
main.c:79:34: error: unknown type name 'queue_t'
   79 | static bool dequeue_check_params(queue_t *const q, size_t len)
      |                                  ^~~~~~~
main.c:88:1: error: unknown type name 'bool'
   88 | bool queue_dequeue(queue_t *const q, void *data, size_t len)
      | ^~~~
main.c:88:1: note: 'bool' is defined in header '<stdbool.h>'; this is probably fixable by adding '#include <stdbool.h>'
main.c:88:20: error: unknown type name 'queue_t'
   88 | bool queue_dequeue(queue_t *const q, void *data, size_t len)
      |                    ^~~~~~~
main.c: In function 'main':
main.c:115:3: error: unknown type name 'queue_t'
  115 |   queue_t *q = queue_create(sizeof(process_t) * 256 * 1000);
      |   ^~~~~~~
main.c:121:5: error: implicit declaration of function 'queue_enqueue' [-Wimplicit-function-declaration]
  121 |     queue_enqueue(q, (void *)&process, sizeof(process));
      |     ^~~~~~~~~~~~~
main.c:127:5: error: implicit declaration of function 'queue_dequeue' [-Wimplicit-function-declaration]
  127 |     queue_dequeue(q, (void *)&process, sizeof(process));
      |     ^~~~~~~~~~~~~
main.c:137:3: error: implicit declaration of function 'queue_destroy' [-Wimplicit-function-declaration]
  137 |   queue_destroy(q);
      |   ^~~~~~~~~~~~~