Input and Output

The question asked throughout the course was always the same: at which stage is this decision made. Input and output fits the course’s closing lesson well, because it can spread that question across all four stages within a single line. In a write call, a macro inside the format string is substituted at the preprocessor, the string’s text is fixed at the compiler, the called function’s definition is found at linking, and what the string means is only known at runtime.

This lesson measures that distribution. The measurement continues from where the core’s value computed from data line left off: there, a sum was computed at runtime; here, the question is how that sum is written.

Nine Observations

// inputoutput.c — at which stage a format string is decided
#include <stdio.h>
#include <string.h>

#define LABEL "measurement"

static void observe(const char *name, const char *stage, const char *evidence) {
    printf("%-34s%-14s%s\n", name, stage, evidence);
}

int main(void) {
    char buffer[64];
    char small[8];

    printf("%-34s%-14s%s\n", "observation", "stage", "evidence");

    /* preprocessor */
    snprintf(buffer, sizeof buffer, "the %s label was placed into the text", LABEL);
    observe("macro in the format string", "preprocessor", buffer);

    /* compiler */
    snprintf(buffer, sizeof buffer, "element count %d", (int)(sizeof buffer / sizeof buffer[0]));
    observe("buffer length", "compiler", buffer);

    const char *constant = "value: %d";
    snprintf(buffer, sizeof buffer, "text is %d characters", (int)strlen(constant));
    observe("text of the format string", "compiler", buffer);

    /* linker */
    observe("formatting function definition", "linker", "no definition in the source, the call was still resolved");

    /* runtime */
    int value = 42;
    const char *format = (value < 100) ? "%d" : "[%d]";
    snprintf(buffer, sizeof buffer, format, value);
    observe("format string selection", "runtime", buffer);

    int width = (int)strlen("four") + 1;
    snprintf(buffer, sizeof buffer, "%*d", width, value);
    observe("field width argument", "runtime", buffer);

    int wanted = snprintf(small, sizeof small, "%s", "hello, world!");
    snprintf(buffer, sizeof buffer, "wanted %d written %d", wanted, (int)strlen(small));
    observe("truncated write", "runtime", buffer);

    int assigned = 0, number = 0;
    assigned = sscanf("temperature 21 degrees", "temperature %d", &number);
    snprintf(buffer, sizeof buffer, "assigned fields %d value %d", assigned, number);
    observe("reading from text", "runtime", buffer);

    int unmatched = sscanf("temperature twentyone", "temperature %d", &number);
    snprintf(buffer, sizeof buffer, "assigned fields %d", unmatched);
    observe("non-matching read", "runtime", buffer);

    printf("\n%-14s%d\n", "preprocessor", 1);
    printf("%-14s%d\n", "compiler", 2);
    printf("%-14s%d\n", "linker", 1);
    printf("%-14s%d\n", "runtime", 5);
    printf("total observations: %d\n", 9);
    return 0;
}

observation                       stage         evidence
macro in the format string        preprocessor  the measurement label was placed into the text
buffer length                     compiler      element count 64
text of the format string         compiler      text is 9 characters
formatting function definition    linker        no definition in the source, the call was still resolved
format string selection           runtime       42
field width argument              runtime          42
truncated write                   runtime       wanted 13 written 7
reading from text                 runtime       assigned fields 1 value 21
non-matching read                 runtime       assigned fields 0

preprocessor  1
compiler      2
linker        1
runtime       5
total observations: 9

BS14. The LABEL macro was placed into the format string before the compiler ever saw the source. To the preprocessor this is a text substitution; it does not know the string is a format string, nor does it know the difference between %s and %d. This is why a format string built with a macro passes the preprocessor stage without any trouble, even if it does not match the argument list.

BS15. The buffer’s length is known at compile time: sizeof buffer / sizeof buffer[0] is a constant expression and gives 64. That an array’s length is known at compile time was measured in the Arrays and Strings lesson; here the same information is used as a write call’s bound. The format string’s text falls into the same class — value: %d is nine characters, and this number is read from the source, not from runtime.

BS16. The formatting function’s definition is not in the source. Only its declaration, coming from a header file, is present, and yet the call was resolved regardless: the linker found the definition. This is the same as the function in another unit line in the Functions lesson; the only difference is that this time the definition sits not in a separate source unit, but in the language’s standard library.

BS17. The remaining five observations fall to runtime, and what they all share is this: the result can change without the source text changing. The format string was chosen by a condition (value < 100 is true, so the bracket-free form was used), the field width came from an argument ("four" opened a five-character field), a write was truncated, a number was read from a piece of text, and one read was unable to assign any field at all.

What the Return Value Says

BS18. The truncated write line shows what the return value is: wanted 13 written 7. A write function returns not the number of characters it managed to fit into the buffer, but how many characters it would have written had it been able to fit them all. When a thirteen-character piece of text is placed into an eight-byte buffer, seven characters and a terminator were written, but the return value stayed at thirteen. This divergence between the two numbers is the only deterministic way of telling whether truncation occurred: if the return value is smaller than the buffer’s length, the write is complete.

BS19. On the read side, the return value counts something else: how many fields were assigned. The same format string assigned one field in one piece of text, zero in the other. The second piece of text was also valid text and the program did not crash — only the number variable stayed untouched. A read’s failure is reported not with an error value but with a count, and a source that does not read that count assumes an unassigned variable is assigned.

The Bounding Measurement

BS20. The language itself does not guarantee the match between a format string and its arguments. In the measurement above, the format string came, at one point, from a variable — the format pointer, chosen by a condition. In that call, the compiler had no information available to check the arguments against, by looking at the string’s contents; the string was chosen at runtime. When a format string is a constant written in the source, the compiler does have the information to check the match, and common compilers offer this as an optional warning. The check itself is not a guarantee of the language: the standard classifies an argument mismatching its format specifier directly as undefined behavior and prescribes no check at all. When the string comes from a variable, even that information is gone — the check drops, and the responsibility passes entirely to the writer.

This is the sharpest result of the course’s four-stage question: the same call shifts from the compiler class to the runtime class depending on where the format string comes from. The source text is almost identical; the only thing that changes is at which stage a piece of information is available.

Closing Table

The decisions measured across thirteen lessons are gathered below. The stage cell is taken from what is written in each lesson’s own text; lessons measuring more than one stage carry both.

Summary

• A single write call can carry all four stages at once: the macro was decided at the preprocessor, the buffer length and the string’s text at the compiler, the function’s definition at the linker, the string’s meaning at runtime.
• Of the nine observations, one was measured at the preprocessor, two at the compiler, one at the linker, five at runtime; input and output is where the course’s four classes mix most densely.
• A write function’s return value is not the number of characters written but the number wanted: thirteen were wanted, seven were written, the return stayed at thirteen.
• A read function’s return value is the number of assigned fields; in a read that returns zero, the target variable stays untouched, and the only way to notice this is to read that count.
• While a format string is a constant in the source, the compiler can check argument agreement; once the string comes from a variable, the same call shifts to the runtime class and the check drops.

Course Wrap-Up

One single question was asked across thirteen lessons: at which stage is this decision made. The common definition’s fourteen observations had been distributed as 4 preprocessor, 4 compiler, 3 linker, 3 runtime, and this distribution never changed throughout the course — what changed was which mechanism fell into which class.

The Language and Compilation topic put the question to the path along which a source turns into a program: to the existence of the four stages, to declarations being shared as text, to the preprocessor not knowing type, and to where a warning is born. The Basic Syntax topic carried the same question into the language’s own structures: to the value a type carries, to a name’s visibility and a value’s storage duration being separate questions, to an operator changing meaning by type, to where a call is resolved, to when a length is known, and to how a record type’s fields are laid out.

The course’s single most repeated finding is this: the same source text behaves differently depending on at which stage a piece of information is available. An array’s length is known at compile time, a string’s at runtime; a macro does not know type, a compiler does; a name is written the same way in two units but may not be the same object.

The next course looks at memory and pointers: where a value sits, who allocates it, and when it is released. In C, all of these questions are written in the source, and none of them is checked on its own.