02-预处理与词法分析¶

// preprocess_demo.c
#include <stdio.h>

#define MAX_SIZE 100
#define SQUARE(x) ((x) * (x))

#ifdef DEBUG
    #define LOG(msg) printf("[DEBUG] %s\n", msg)
#else
    #define LOG(msg)
#endif

int main() {
    int arr[MAX_SIZE];
    int result = SQUARE(5 + 1);
    LOG("程序开始");
    printf("result = %d\n", result);
    return 0;
}

// 宏陷阱示例
#include <stdio.h>

// 陷阱1：缺少括号的宏
#define BAD_SQUARE(x) x * x
#define GOOD_SQUARE(x) ((x) * (x))

// 陷阱2：带副作用的宏参数
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    // 陷阱1演示
    printf("BAD:  %d\n", BAD_SQUARE(3 + 1));   // 3+1*3+1 = 7，不是16
    printf("GOOD: %d\n", GOOD_SQUARE(3 + 1));   // ((3+1)*(3+1)) = 16

    // 陷阱2演示
    int a = 5, b = 3;
    int m = MAX(a++, b++);
    // a++被执行了两次！结果不可预期
    printf("a=%d, b=%d, max=%d\n", a, b, m);

    return 0;
}

// simple_lexer.c - 简单词法分析器
#include <stdio.h>  // 引入头文件
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

// Token类型枚举
typedef enum {
    TOKEN_INT,        // int关键字
    TOKEN_RETURN,     // return关键字
    TOKEN_IF,         // if关键字
    TOKEN_ELSE,       // else关键字
    TOKEN_IDENTIFIER, // 标识符
    TOKEN_NUMBER,     // 数字
    TOKEN_PLUS,       // +
    TOKEN_MINUS,      // -
    TOKEN_STAR,       // *
    TOKEN_SLASH,      // /
    TOKEN_ASSIGN,     // =
    TOKEN_EQ,         // ==
    TOKEN_LPAREN,     // (
    TOKEN_RPAREN,     // )
    TOKEN_LBRACE,     // {
    TOKEN_RBRACE,     // }
    TOKEN_SEMICOLON,  // ;
    TOKEN_EOF,        // 文件结束
    TOKEN_UNKNOWN     // 未知
} TokenType;

// Token结构
typedef struct {
    TokenType type;
    char value[256];
    int line;
    int column;
} Token;

// 词法分析器状态
typedef struct {
    const char *source;  // 指针：存储变量的内存地址
    int pos;
    int line;
    int column;
} Lexer;

// 关键字表
static const char *keywords[] = {"int", "return", "if", "else"};
static const TokenType keyword_types[] = {
    TOKEN_INT, TOKEN_RETURN, TOKEN_IF, TOKEN_ELSE
};
#define NUM_KEYWORDS 4

// 初始化词法分析器
void lexer_init(Lexer *lex, const char *source) {
    lex->source = source;
    lex->pos = 0;
    lex->line = 1;
    lex->column = 1;
}

// 获取当前字符
char current(Lexer *lex) {
    return lex->source[lex->pos];
}

// 前进一个字符
void advance(Lexer *lex) {
    if (current(lex) == '\n') {
        lex->line++;
        lex->column = 1;
    } else {
        lex->column++;
    }
    lex->pos++;
}

// 跳过空白字符和注释
void skip_whitespace(Lexer *lex) {
    while (current(lex)) {
        if (isspace(current(lex))) {
            advance(lex);
        } else if (current(lex) == '/' && lex->source[lex->pos + 1] == '/') {
            // 单行注释
            while (current(lex) && current(lex) != '\n') advance(lex);
        } else {
            break;
        }
    }
}

// 读取标识符或关键字
Token read_identifier(Lexer *lex) {
    Token tok;
    tok.line = lex->line;
    tok.column = lex->column;
    int start = lex->pos;

    while (isalnum(current(lex)) || current(lex) == '_') {
        advance(lex);
    }

    int len = lex->pos - start;
    strncpy(tok.value, lex->source + start, len);
    tok.value[len] = '\0';

    // 检查是否为关键字
    tok.type = TOKEN_IDENTIFIER;
    for (int i = 0; i < NUM_KEYWORDS; i++) {
        if (strcmp(tok.value, keywords[i]) == 0) {
            tok.type = keyword_types[i];
            break;
        }
    }
    return tok;
}

// 读取数字
Token read_number(Lexer *lex) {
    Token tok;
    tok.type = TOKEN_NUMBER;
    tok.line = lex->line;
    tok.column = lex->column;
    int start = lex->pos;

    while (isdigit(current(lex))) advance(lex);

    int len = lex->pos - start;
    strncpy(tok.value, lex->source + start, len);
    tok.value[len] = '\0';
    return tok;
}

// 获取下一个Token
Token next_token(Lexer *lex) {
    skip_whitespace(lex);
    Token tok;
    tok.line = lex->line;
    tok.column = lex->column;

    char c = current(lex);
    if (c == '\0')   { tok.type = TOKEN_EOF;  strcpy(tok.value, "EOF"); return tok; }
    if (isalpha(c) || c == '_') return read_identifier(lex);
    if (isdigit(c))             return read_number(lex);

    advance(lex);
    tok.value[0] = c; tok.value[1] = '\0';
    switch (c) {
        case '+': tok.type = TOKEN_PLUS;      break;
        case '-': tok.type = TOKEN_MINUS;     break;
        case '*': tok.type = TOKEN_STAR;      break;
        case '/': tok.type = TOKEN_SLASH;     break;
        case '(': tok.type = TOKEN_LPAREN;    break;
        case ')': tok.type = TOKEN_RPAREN;    break;
        case '{': tok.type = TOKEN_LBRACE;    break;
        case '}': tok.type = TOKEN_RBRACE;    break;
        case ';': tok.type = TOKEN_SEMICOLON; break;
        case '=':
            if (current(lex) == '=') {
                advance(lex);
                tok.type = TOKEN_EQ;
                strcpy(tok.value, "==");
            } else {
                tok.type = TOKEN_ASSIGN;
            }
            break;
        default: tok.type = TOKEN_UNKNOWN; break;
    }
    return tok;
}

// 测试主函数
int main() {
    const char *code = "int main() {\n"
                       "    int x = 42;\n"
                       "    return x + 1;\n"
                       "}\n";

    printf("源代码：\n%s\n", code);
    printf("Token序列：\n");
    printf("%-4s %-16s %-14s %s\n", "行", "类型", "值", "位置");
    printf("──────────────────────────────────────────\n");

    Lexer lex;
    lexer_init(&lex, code);
    Token tok;
    do {
        tok = next_token(&lex);
        printf("%-4d %-16d %-14s (%d:%d)\n",
               tok.line, tok.type, tok.value, tok.line, tok.column);
    } while (tok.type != TOKEN_EOF);

    return 0;
}