Stack using an ADT interface

#include <stdio.h>

stdio.h declares printf, puts, getchar and putchar. The input helper reads characters with getchar; the main program prints operation results using the output functions.

#include <stdlib.h>

stdlib.h declares strtol for converting an integer token. It also declares malloc and free, which the linked structures and tree programs use to obtain and release node storage.

#include <string.h>

string.h declares utilities such as memset. It is part of the shared header list; merely including a header does not call any function or change stored values.

#include <ctype.h>
#include <errno.h>

ctype.h supplies isspace for recognising whitespace. errno.h supplies errno so the program can detect a range error reported by strtol.

/* Read a complete integer token; reject bad or oversized input safely. */
int readInt(int *value) {

The comment states the purpose of readInt. Its int *value parameter receives the address of a caller variable. The helper returns 1 after storing a valid value there, or 0 on failure; these flags are separate from main’s process exit status.

    char token[64];
    int ch;
    size_t used = 0;

token holds up to 63 input characters and a null terminator. ch is int so it can distinguish character input from EOF. used starts at zero and counts the stored token characters.

    while ((ch = getchar()) != EOF && isspace((unsigned char)ch)) { }
    if (ch == EOF) return 0;

getchar reads one character at a time. The loop discards whitespace before the token. The unsigned-char cast supplies an allowed argument to isspace. If EOF is reached before a token starts, return 0 without changing the caller variable.

    do {
        if (used < sizeof token - 1) token[used++] = (char)ch;

The do-while body handles the first non-whitespace character already read. The size check leaves one buffer slot for a null terminator. used++ uses the old index for storage, then advances the count.

        else {
            while ((ch = getchar()) != EOF && !isspace((unsigned char)ch)) { }
            return 0;
        }

When the buffer has no character space left, consume the rest of that token through whitespace or EOF, then return failure. The program does not silently treat a truncated prefix as the full input number.

        ch = getchar();
    } while (ch != EOF && !isspace((unsigned char)ch));

Keep collecting until whitespace or EOF. The terminating whitespace has been consumed by getchar; it is not stored as part of the token.

    token[used] = '\0';
    char *end;
    errno = 0;

Write the null terminator after the stored token. end will identify where conversion stopped. Reset errno before strtol so a previous library error cannot be mistaken for this conversion’s result.

    long result = strtol(token, &end, 10);

strtol reads token in base 10 and returns a long. Passing &end lets it write the address of the first unconverted character. A sign such as - is allowed as part of a valid integer token.

    if (errno || *end != '\0' || result < -1000000 || result > 1000000) return 0;

A nonzero errno rejects a reported conversion error. *end must be the null terminator, so input such as 12x is rejected rather than accepted as 12. The allowed value range is -1,000,000 to 1,000,000.

    *value = (int)result;
    return 1;
}

After validation, cast result to int and assign it through *value. Return 1 for success. The brace ends readInt. The caller variable remains unchanged on the earlier failure returns.

/* Stack ADT interface: init, push, pop, peek, display, destroy.
   A linked list is the implementation; callers use these operations. */

The comment names the ADT operations. An abstract data type describes the allowed behaviour; this particular implementation uses linked nodes. The caller requests push or pop rather than manipulating links itself.

typedef struct Node { int data; struct Node *next; } Node;
typedef struct { Node *top; } Stack;

Each Node contains an integer and next link. Stack stores only top, the address of the most recently pushed node. The typedef names shorten later function declarations.

void initStack(Stack *s) { s->top = NULL; }

s points to the caller’s Stack object. Setting s->top to NULL gives it an explicit empty state before any operation reads top.

int push(Stack *s, int value) {
    Node *node = malloc(sizeof *node);
    if (!node) return 0;

Reserve one Node. If malloc returns NULL, return 0 before changing top. The existing stack therefore remains intact on allocation failure.

    node->data = value; node->next = s->top; s->top = node;
    return 1;
}

Store value, point node->next at the current top, then make top identify node. Preserving the old top in the new next link keeps the whole stack reachable. Return success.

int pop(Stack *s, int *value) {
    if (!s->top) return 0;

value is an output pointer. A null top means underflow, so return failure before trying to access a node.

    Node *node = s->top; *value = node->data;
    s->top = node->next; free(node);
    return 1;
}

Keep the old top in node and copy its integer through *value. Advance s->top to node->next before freeing node. Return 1; the caller may use the copied integer, but must not use the removed node.

int peek(const Stack *s, int *value) {
    if (!s->top) return 0;
    *value = s->top->data; return 1;
}

The const Stack parameter means this operation does not change the stack object through s. Return 0 for empty; otherwise copy the top integer through value and return 1. No node is freed.

void display(const Stack *s) {
    printf("Stack (top to bottom):");
    for (const Node *p = s->top; p; p = p->next) printf(" %d", p->data);
    putchar('\n');
}

Begin p at top, print each stored integer and follow next until NULL. Only the traversal pointer changes, so the stack contents remain available afterward.

void destroyStack(Stack *s) { int ignored; while (pop(s, &ignored)) { } }

Keep calling pop until it returns 0. ignored receives each removed integer but is not otherwise needed. pop releases each node, and top eventually becomes NULL.

/* 1 value: push; 2: pop; 3: peek; 4: display; 0: exit. */
int main(void) {

The comment gives the operation protocol. main uses the ADT functions as its interface to the linked representation.

    Stack s; initStack(&s);
    int command, value;

Declare the Stack object and immediately pass its address to initStack. command and value hold input tokens and valid output results.

    while (readInt(&command)) {
        if (command == 0) { destroyStack(&s); return 0; }

Continue while a command can be read. Command 0 destroys all nodes before returning success; dynamic allocations do not disappear merely because the top pointer is no longer used.

        if (command == 1) {
            if (!readInt(&value)) break;
            puts(push(&s, value) ? "Pushed." : "Allocation failed; stack unchanged.");

Command 1 reads its required value. A failed read breaks to cleanup. Otherwise call push and print either success or allocation-failure text; a failed push leaves the stack unchanged.

        } else if (command == 2) {
            if (pop(&s, &value)) printf("Popped: %d\n", value);
            else puts("Underflow: stack is empty.");

For command 2, print value only if pop returned success. Otherwise the output variable must not be treated as a removed item.

        } else if (command == 3) {
            if (peek(&s, &value)) printf("Top: %d\n", value);
            else puts("Stack is empty.");

For command 3, the helper returns the top value without removing it. The caller prints it only on success.

        } else if (command == 4) display(&s);
        else break;
    }

Command 4 calls display. Another command breaks out of the loop; the brace finishes the command body.

    puts("Invalid or incomplete input. End with command 0.");
    destroyStack(&s); return 1;
}

Print the error report, destroy the remaining stack and return failure. Both normal and error exits therefore have a cleanup path.