词法分析器c语言编写详细代码及流程图

词法分析器是编译器的一个组成部分，主要负责将源代码转换为一系列的标记符号（Token），每个标记符号代表着源代码中的一个语法元素，如关键字、标识符、常量、运算符等等。下面是一个简单的词法分析器的实现，使用C语言编写。

首先，我们需要定义Token结构体，包含TokenType和TokenValue两个成员变量。其中，TokenType表示标记符号的类型，TokenValue表示标记符号的值。

typedef enum {
    TOKEN_TYPE_KEYWORD,     // 关键字
    TOKEN_TYPE_IDENTIFIER, // 标识符
    TOKEN_TYPE_CONSTANT,    // 常量
    TOKEN_TYPE_OPERATOR,    // 运算符
    TOKEN_TYPE_DELIMITER    // 分隔符
} TokenType;

typedef struct {
    TokenType type;         // 标记符号类型
    char* value;            // 标记符号值
} Token;

接下来，我们需要定义一些常量，表示关键字、运算符和分隔符等。

const char* KEYWORDS[] = {"if", "else", "while", "for", "int", "float", "double", "char", "void"};
const char* OPERATORS[] = {"+", "-", "*", "/", "=", "<", ">", "==", "!="};
const char* DELIMITERS[] = {";", ",", "(", ")", "{", "}"};

然后，我们需要实现一个函数，用于判断一个字符是否为字母或下划线。如果是，则返回1，否则返回0。

int is_letter(char c) {
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_');
}

接下来，我们需要实现一个函数，用于判断一个字符是否为数字。如果是，则返回1，否则返回0。

int is_digit(char c) {
    return c >= '0' && c <= '9';
}

然后，我们需要实现一个函数，用于判断一个字符是否为关键字。如果是，则返回关键字的TokenType，否则返回0。

TokenType get_keyword_type(char* str) {
    int i;
    for (i = 0; i < sizeof(KEYWORDS) / sizeof(KEYWORDS[0]); i++) {
        if (strcmp(str, KEYWORDS[i]) == 0) {
            return TOKEN_TYPE_KEYWORD;
        }
    }
    return 0;
}

接下来，我们需要实现一个函数，用于判断一个字符是否为运算符。如果是，则返回运算符的TokenType，否则返回0。

TokenType get_operator_type(char* str) {
    int i;
    for (i = 0; i < sizeof(OPERATORS) / sizeof(OPERATORS[0]); i++) {
        if (strcmp(str, OPERATORS[i]) == 0) {
            return TOKEN_TYPE_OPERATOR;
        }
    }
    return 0;
}

然后，我们需要实现一个函数，用于判断一个字符是否为分隔符。如果是，则返回分隔符的TokenType，否则返回0。

TokenType get_delimiter_type(char* str) {
    int i;
    for (i = 0; i < sizeof(DELIMITERS) / sizeof(DELIMITERS[0]); i++) {
        if (strcmp(str, DELIMITERS[i]) == 0) {
            return TOKEN_TYPE_DELIMITER;
        }
    }
    return 0;
}

接下来，我们需要实现一个函数，用于将源代码转换为一系列的标记符号。该函数接受源代码字符串作为参数，返回一个Token数组。

Token* tokenize(char* source) {
    Token* tokens = (Token*)malloc(sizeof(Token) * MAX_TOKENS);
    int num_tokens = 0;
    int source_len = strlen(source);
    int i = 0;
    while (i < source_len) {
        char c = source[i];
        if (is_letter(c)) {
            // 处理标识符
            char* start = source + i;
            i++;
            while (i < source_len && (is_letter(source[i]) || is_digit(source[i]))) {
                i++;
            }
            char* end = source + i;
            int len = end - start;
            char* str = (char*)malloc(len + 1);
            strncpy(str, start, len);
            str[len] = '\0';
            TokenType type = get_keyword_type(str);
            if (type == 0) {
                type = TOKEN_TYPE_IDENTIFIER;
            }
            Token token = {type, str};
            tokens[num_tokens++] = token;
        } else if (is_digit(c)) {
            // 处理常量
            char* start = source + i;
            i++;
            while (i < source_len && is_digit(source[i])) {
                i++;
            }
            char* end = source + i;
            int len = end - start;
            char* str = (char*)malloc(len + 1);
            strncpy(str, start, len);
            str[len] = '\0';
            Token token = {TOKEN_TYPE_CONSTANT, str};
            tokens[num_tokens++] = token;
        } else if (c == '/' && i < source_len - 1 && source[i+1] == '/') {
            // 处理注释
            i += 2;
            while (i < source_len && source[i] != '\n') {
                i++;
            }
        } else if (isspace(c)) {
            // 忽略空格和换行符
            i++;
        } else {
            // 处理运算符和分隔符
            char* start = source + i;
            i++;
            while (i < source_len) {
                char* str = (char*)malloc(3);
                strncpy(str, start, 1);
                str[1] = '\0';
                TokenType type = get_operator_type(str);
                if (type == 0) {
                    type = get_delimiter_type(str);
                }
                Token token = {type, str};
                tokens[num_tokens++] = token;
                break;
            }
        }
    }
    Token token = {0, NULL};
    tokens[num_tokens++] = token;
    return tokens;
}

最后，我们需要在主函数中调用tokenize函数，并输出每个标记符号的类型和值。

int main() {
    char source[] = "int main() {\n    int x = 1;\n    int y = 2;\n    int z = x + y;\n    return z;\n}";
    Token* tokens = tokenize(source);
    int i = 0;
    while (tokens[i].value != NULL) {
        printf("%d %s\n", tokens[i].type, tokens[i].value);
        i++;
    }
    return 0;
}

下面是该词法分析器的流程图：