Write-a-C-interpreter is an educational project that guides users through the process of building a simple C interpreter from scratch. It aims to help developers understand the inner workings of programming languages and compilers by implementing a basic C interpreter in C.

Pros

• Provides a hands-on learning experience for understanding language interpretation and compilation
• Offers step-by-step explanations and implementation details
• Helps developers gain insights into low-level programming concepts
• Serves as a foundation for further exploration of compiler design and language implementation

Cons

• Limited to a subset of the C language, not a full-featured interpreter
• May not be suitable for production use or real-world applications
• Requires a solid understanding of C programming and computer science concepts
• Documentation could be more comprehensive for beginners

Code Examples

Here are a few examples of code snippets from the project:

1. Tokenization:

void next() {
    char *last_pos;
    int hash;

    while (token = *src) {
        ++src;

        if (token == '\n') {
            ++line;
        }
        else if (token == '#') {
            // skip macro, because we will not support it
            while (*src != 0 && *src != '\n') {
                src++;
            }
        }
        else if ((token >= 'a' && token <= 'z') || (token >= 'A' && token <= 'Z') || (token == '_')) {
            // parse identifier
            last_pos = src - 1;
            hash = token;

            while ((*src >= 'a' && *src <= 'z') || (*src >= 'A' && *src <= 'Z') || (*src >= '0' && *src <= '9') || (*src == '_')) {
                hash = hash * 147 + *src;
                src++;
            }

            // look for existing identifier, linear search
            current_id = symbols;
            while (current_id[Token]) {
                if (current_id[Hash] == hash && !memcmp((char *)current_id[Name], last_pos, src - last_pos)) {
                    //found one, return
                    token = current_id[Token];
                    return;
                }
                current_id = current_id + IdSize;
            }

            // store new ID
            current_id[Name] = (int)last_pos;
            current_id[Hash] = hash;
            token = current_id[Token] = Id;
            return;
        }
        else if (token >= '0' && token <= '9') {
            // parse number, three kinds: dec(123) hex(0x123) oct(017)
            token_val = token - '0';
            if (token_val > 0) {
                // dec, starts with [1-9]
                while (*src >= '0' && *src <= '9') {
                    token_val = token_val*10 + *src++ - '0';
                }
            } else {
                // starts with 0
                if (*src == 'x' || *src == 'X') {
                    //hex
                    token = *++src;
                    while ((token >= '0' && token <= '9') || (token >= 'a' && token <= 'f') || (token >= 'A' && token <= 'F')) {
                        token_val = token_val * 16 + (token & 15) + (token >= 'A' ? 9 : 0);
                        token = *++src;
                    }
                } else {
                    // oct
                    while (*src >= '0' && *src <= '7') {
                        token_val = token_val*8 + *src++ - '0';
                    }
                }
            }
            token = Num;
            return;
        }
        // ... (more token parsing)
    }
}

This code snippet demonstrates the tokenization process, parsing identifiers and numbers from the input source code.

2. Expression parsing:

void expression(int level) {
    // parse expressions
    int *i