编译器----词法分析

最新推荐文章于 2024-05-31 08:41:37 发布
最新推荐文章于 2024-05-31 08:41:37 发布
阅读量3.9k 收藏 22
点赞数 4
分类专栏： 编译器 文章标签： 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zach_z/article/details/80029826
版权

本文通过学习王博俊、张宇的《DIY Compiler and Linker》 ，实现词法分析器，一方面作为自己的学习笔记，一方面也作与大家分享与交流

代码下载地址

词法分析的任务

源程序由字符序列构成，词法分析器扫描源程序字符串，根据语言的词法规则分析并识别具有独立意义的最小语法单位：单词(包括关键字、运算符、标识符等)，并以某种编码形式输出。

词法分析流程图

这次实现的词法分析器完全按照下图所编写：
这里写图片描述

从图中可以看到
1. 先打开源文件，如果无法打开则异常退出
2. 打开源文件后进行初始化，标致行号为第一行，再初始化动态数组，并把运算符、关键字、常量直接放入单词表（单词表是由动态数组和哈希表一起组成的复合结构）
3. 开始读取一个字符，并从第一个字符开始进行“取单词”的工作，如果遇到空白字符或者注释则忽略，如果是有效字符则判断这一单词并给出编号或者标识符索引码
4. 为了能显示出来我们的词法分析，对不同类别的单词进行着色输出到我们屏幕上
5. 循环往复第3、4步直到文件末尾，关闭文件，正常结束

实现词法分析器

1. 自定义动态字符串和动态数组

自定义动态字符串和动态数组是词法分析需要用到的数据结构

  • 首先，常量字符串的长度没办法预知，可能是空串，也可能很长，则需要动态字符串来存储
  • 其次，单词的个数也无法预知，可能只有一个单词，也可能有许多，对于单词的存储，也需要一个按需分配的动态数组

词法分析器是用C语言写的，需要自定义动态字符串和动态数组

1.1 动态字符串

dynstring.h(实际上放在头文件lexical_analysis.h):

/*动态字符串定义*/
typedef struct DynString
{
    int count; //字符串长度
    int capacity; //包含该字符串的缓冲区长度
    char *data; //指向字符串的指针
}DynString;
void dynstring_init(DynString *pstr, int initsize);//初始化动态字符串存储容量，用于dynstring_reset()
void dynstring_free(DynString *pstr);//释放动态字符串使用的内存空间,用于dynstring_reset()
void dynstring_realloc(DynString *cstr, int new_size);//重新分配字符串容量
void dynstring_chcat(DynString *cstr, int ch);//字符串中添加字符
void dynstring_reset(DynString *cstr);//重置动态字符串

dynstring.c:

#include "lexical_analysis.h"


/***********************************************************
*  功能:      初始化动态字符串储存容量
*  pstr:        动态字符串指针
*  initsize:    字符串初始化分配空间
**********************************************************/
void dynstring_init(DynString *pstr, int initsize)
{
    if (pstr != NULL)
    {
        pstr->data = (char *)malloc(sizeof(char) * initsize);
        pstr->count = 0;
        pstr->capacity = initsize;
    }
}

/***********************************************************
*  功能:  释放动态字符串使用的内存空间
*  pstr:    动态字符串指针
**********************************************************/
void dynstring_free(DynString *pstr)
{
    if (pstr != NULL)
    {
        if (pstr->data) free(pstr->data);
        pstr->count = 0;
        pstr->capacity = 0;
    }
}

/***********************************************************
*  功能:  重置动态字符串,先释放,重新初始化
*  pstr:    动态字符串指针
**********************************************************/
void dynstring_reset(DynString *pstr)
{
    dynstring_free(pstr);
    dynstring_init(pstr, 10);//初始化字符串分配10个字节空间
}

/***********************************************************
*  功能:      重新分配字符串容量
*  pstr:        动态字符串指针
*  new_size:    字符串新长度
**********************************************************/
void dynstring_realloc(DynString *pstr, int new_size)
{
    int capacity;
    char *data;
    capacity = pstr->capacity;
    while (capacity < new_size)
    {
        capacity *= 2;//本来分配空间扩大一倍
    }
    data = (char *)realloc(pstr->data, capacity);
    if (!data)//realloc 返回NULL 即分配失败
        error("内存分配失败");
    pstr->capacity = capacity;
    pstr->data = data;
}

/***********************************************************
*  功能:  追加单个字符到动态字符串对象
*  pstr:    动态字符串指针
*  ch:      所要追加的字符
**********************************************************/
void dynstring_chcat(DynString *pstr, int ch)
{
    int count;
    count = pstr->count + 1;
    if (count > pstr->capacity)
        dynstring_realloc(pstr, count);
    pstr->data[count - 1] = ch;
    pstr->count = count;
}
1.2 动态数组

dynarray.h(实际上放在头文件lexical_analysis.h):

/*动态数组定义*/
typedef struct DynArray
{
    int count;//动态数组元素个数
    int capacity;//动态数组缓冲区长度
    void **data;//指向数据指针的数组
}DynArray;

void dynarray_realloc(DynArray *parr, int new_size);//重新分配动态数组容量,用于dynarray_add()函数
void dynarray_add(DynArray *parr, void *data);//追加动态数组元素
void dynarray_init(DynArray *parr, int initsize);//初始化动态数组存储容量
void dynarray_free(DynArray *parr);//释放动态数组使用的内存空间
int dynarray_search(DynArray *parr, int key);//动态数组元素查找

dynarray.c:

#include "lexical_analysis.h"

/***********************************************************
* 功能:       初始化动态数组储存容量
* parr:     动态数组指针
* initsize: 动态数组初始化分配空间
**********************************************************/
void dynarray_init(DynArray *parr, int initsize)
{
    if (parr != NULL)
    {
        parr->data = (void **)malloc(sizeof(void*) * initsize);
        parr->count = 0;
        parr->capacity = initsize;
    }
}

/***********************************************************
*  功能:  释放动态数组使用的内存空间
*  parr:    动态数组指针
**********************************************************/
void dynarray_free(DynArray *parr)
{
    void **p;
    for (p = parr->data; parr->count; ++p, --parr->count)
    {
        if (*p)
            free(*p);
    }
    free(parr->data);
    parr->data = NULL;
}
/***********************************************************
*  功能:      重新分配动态数组容量
*  parr:        动态数组指针
*  new_size:    动态数组最新元素个数
**********************************************************/
void dynarray_realloc(DynArray *parr, int new_size)
{
    int capacity;
    void *data;

    capacity = parr->capacity;
    while (capacity < new_size)
        capacity *= 2;
    data = realloc(parr->data, capacity);
    if (!data)
        error("内存分配失败");
    parr->capacity = capacity;
    parr->data = (void **)data;
}

/***********************************************************
*  功能:  追加动态数组元素
*  parr:    动态数组指针
*  data:    所要追加的新元素
**********************************************************/
void dynarray_add(DynArray *parr, void *data)
{
    int count;
    count = parr->count + 1;
    if (count * sizeof(void*) > parr->capacity)
        dynarray_realloc(parr, count * sizeof(void*));
    parr->data[count - 1] = data;
    parr->count = count;
}

/***********************************************************
*  功能:  动态数组元素查找
*  parr:    动态数组指针
*  key: 要查找的元素
**********************************************************/
int dynarray_search(DynArray *parr, int key)
{
    int i;
    int **p;
    p = (int **)parr->data;
    for (i = 0; i < parr->count; ++i, p++)
    {
        if (key == **p)
            return i;
    }
    return -1;
}
1.3 动态字符串与动态数组存储结构图

这里写图片描述

2. 单词表

单词表由动态数组和哈希表两部分构成

2.1 哈希表

单词表中步存储重复的单词，每遇到一个单词就遍历去单词表中查找效率很低，因此需要哈希表

这里使用ELF字符串哈希值计算

ELFhash—字符串哈希算法解释

unsigned int ELFHash(char *str)
{
    unsigned int hash = 0;
    unsigned int x = 0;

    while (*str)
    {
        hash = (hash << 4) + (*str++);
        if ((x=hash & 0xf0000000)!=0)
            hash ^= x >> 24;
        hash &= ~x;
    }
    return (hash & 0x7fffffff);
}
2.2 单词表实现

tkword.h(实际上放在头文件lexical_analysis.h):

/*单词存储结构定义*/
typedef struct TkWord
{
    int tkcode;//单词编码
    struct TkWord *next; //指向哈希冲突的同义词
    char *spelling; //单词字符串
}TkWord;

int ELFHash(char *str);//计算哈希地址
TkWord* tkword_direct_insert(TkWord* tp);//将运算符、关键字、常量直接放入单词表
TkWord* tkword_find(char *p, int keyno);//在单词表中查找单词,用于tkword_insert()
void *mallocz(int size);//分配堆内存并将数据初始化为'0',用于tkword_insert()
TkWord* tkword_insert(char *p);//标识符插入单词表，先查找，查找不到再插入单词表

tkword.c:

#include "lexical_analysis.h"

TkWord* tk_hashtable[MAXKEY];   // 单词哈希表
DynArray tktable;       // 单词表

/***********************************************************
* 功能:   计算哈希地址
* key:哈希关键字
* MAXKEY:哈希表长度
**********************************************************/
int ELFHash(char *str)
{
    int hash = 0;
    int x = 0;

    while (*str)
    {
        hash = (hash << 4) + *str++;
        x = hash & 0xf0000000;
        if (x)
            hash ^= x >> 24;
        hash &= ~x;
    }
    return hash % MAXKEY;
}

/***********************************************************
* 功能: 将运算符、关键字、常量直接放入单词表
* tp:    单词指针
**********************************************************/
TkWord* tkword_direct_insert(TkWord* tp)
{
    int keyno;
    dynarray_add(&tktable, tp);
    keyno = ELFHash(tp->spelling);
    tp->next = tk_hashtable[keyno];
    tk_hashtable[keyno] = tp;
    return tp;
}

/***********************************************************
* 功能:    在单词表中查找单词
*  p:       单词字符串指针
*  keyno:   单词的哈希值
**********************************************************/
TkWord* tkword_find(char *p, int keyno)
{
    TkWord *tp = NULL, *tp1;
    for (tp1 = tk_hashtable[keyno]; tp1; tp1 = tp1->next)
    {
        if (!strcmp(p, tp1->spelling))
        {
            token = tp1->tkcode;
            tp = tp1;
        }
    }
    return tp;
}

/***********************************************************
* 功能:   分配堆内存并将数据初始化为'0'
* size: 分配内存大小
**********************************************************/
void *mallocz(int size)
{
    void *ptr;
    ptr = malloc(size);
    if (!ptr && size)
        error("内存分配失败");
    memset(ptr, 0, size);
    return ptr;
}

/***********************************************************
* 功能:   标识符插入单词表，先查找，查找不到再插入单词表
* p:        单词字符串指针
**********************************************************/
TkWord* tkword_insert(char *p)
{
    TkWord *tp;
    int keyno;
    char *s;
    char *end;
    int length;

    keyno = ELFHash(p);
    tp = tkword_find(p, keyno);
    if (tp == NULL)
    {
        length = strlen(p);
        tp = (TkWord*)mallocz(sizeof(TkWord) + length + 1);
        tp->next = tk_hashtable[keyno];
        tk_hashtable[keyno] = tp;
        dynarray_add(&tktable, tp);
        tp->tkcode = tktable.count - 1;
        s = (char*)tp + sizeof(TkWord);
        tp->spelling = (char *)s;
        for (end = p + length; p < end;)
        {
            *s++ = *p++;
        }
        *s = (char)'\0';
    }
    return tp;
}
2.3 单词表存储结构

这里写图片描述

3.错误处理

在进行词法分析之前，还需要先做一个错误处理的部分，在编译和链接的过程中，需要根据错误种类和具体错误，来直观的输出错误

error.h(实际上放在头文件lexical_analysis.h):

/* 错误级别 */
enum e_ErrorLevel
{
    LEVEL_WARNING,
    LEVEL_ERROR,
};

/* 工作阶段 */
enum e_WorkStage
{
    STAGE_COMPILE,
    STAGE_LINK,
};

void handle_exception(int stage, int level, char *fmt, va_list ap);//异常处理：作为编译警告、错误和链接错误调用的功能函数
void warning(char *fmt, ...);//编译警告处理
void error(char *fmt, ...);//错误处理
void expect(char *msg);//提示错误，此处缺少某个语法成分
void link_error(char *fmt, ...);//链接错误处理
void *get_tkstr(int v);//取得单词v所代表的源码字符串

error.c:

#include "lexical_analysis.h"

/******************************************************************
* 异常处理
* stage: 编译阶段还是链接阶段
* level：错误级别
* fmt：参数输出格式
* ap：可变参数列表
*******************************************************************/
void handle_exception(int stage, int level, char *fmt, va_list ap)
{
    char buf[1024];
    vsprintf(buf, fmt, ap);
    if (stage == STAGE_COMPILE)
    {
        if (level == LEVEL_WARNING)
            printf("%s(第%d行): 编译警告: %s!\n", filename, line_num, buf);
        else
        {
            printf("%s(第%d行): 编译错误: %s!\n", filename, line_num, buf);
            exit(-1);
        }
    }
    else
    {
        printf("链接错误: %s!\n", buf);
        exit(-1);
    }
}

/******************************************************************
* 编译警告处理
* fmt：参数输出格式
* ap：可变参数列表
*******************************************************************/
void warning(char *fmt, ...)
{
    va_list ap = NULL;
    va_start(ap, fmt);
    handle_exception(STAGE_COMPILE, LEVEL_WARNING, fmt, ap);
    va_end(ap);
}

/******************************************************************
* 编译错误处理
* fmt：参数输出格式
* ap：可变参数列表
*******************************************************************/
void error(char *fmt, ...)
{
    va_list ap = NULL;
    va_start(ap, fmt);
    handle_exception(STAGE_COMPILE, LEVEL_ERROR, fmt, ap);
    va_end(ap);
}

/******************************************************************
* 链接错误处理
* fmt：参数输出格式
* ap：可变参数列表
*******************************************************************/
void link_error(char *fmt, ...)
{
    va_list ap = NULL;
    va_start(ap, fmt);
    handle_exception(STAGE_LINK, LEVEL_ERROR, fmt, ap);
    va_end(ap);
}

/******************************************************************
* 提示错误，此处缺少某个语法成分
* msg：需要什么语法成分
*******************************************************************/
void expect(char *msg)
{
    error("缺少%s", msg);
}

/******************************************************************
* 功能：取得单词v所代表的源码字符串
* v：单词编号
*******************************************************************/
char *get_tkstr(int v)
{
    if (v > tktable.count)
        return NULL;
    else if (v >= TK_CINT && v <= TK_CSTR)
        return sourcestr.data;
    else
        return ((TkWord*)tktable.data[v])->spelling;
}

4. 词法分析

将源程序的字符串解析成一个个单词符号
这里写图片描述

4.1 单词编码

因为要把字符串解析成一个个单词，而这些单词有可能是运算符有可能是关键字，也有可能是自定义的标识符，所以需要给他们绑定一个身份
lexical_analysis.h:

/* 单词编码 */
enum e_TokenCode
{
    /* 运算符及分隔符 */
    TK_PLUS,        // + 加号
    TK_MINUS,       // - 减号
    TK_STAR,        // * 星号
    TK_DIVIDE,      // / 除号
    TK_MOD,         // % 求余运算符
    TK_EQ,          // == 等于号
    TK_NEQ,         // != 不等于号
    TK_LT,          // < 小于号
    TK_LEQ,         // <= 小于等于号
    TK_GT,          // > 大于号
    TK_GEQ,         // >= 大于等于号
    TK_ASSIGN,      // = 赋值运算符 
    TK_POINTSTO,    // -> 指向结构体成员运算符
    TK_DOT,         // . 结构体成员运算符
    TK_AND,         // & 地址与运算符
    TK_OPENPA,      // ( 左圆括号
    TK_CLOSEPA,     // ) 右圆括号
    TK_OPENBR,      // [ 左中括号
    TK_CLOSEBR,     // ] 右圆括号
    TK_BEGIN,       // { 左大括号
    TK_END,         // } 右大括号
    TK_SEMICOLON,   // ; 分号    
    TK_COMMA,       // , 逗号
    TK_ELLIPSIS,    // ... 省略号
    TK_EOF,         // 文件结束符

    /* 常量 */
    TK_CINT,        // 整型常量
    TK_CCHAR,       // 字符常量
    TK_CSTR,        // 字符串常量                                

    /* 关键字 */
    KW_CHAR,        // char关键字
    KW_SHORT,       // short关键字
    KW_INT,         // int关键字
    KW_VOID,        // void关键字  
    KW_STRUCT,      // struct关键字   
    KW_IF,          // if关键字
    KW_ELSE,        // else关键字
    KW_FOR,         // for关键字
    KW_CONTINUE,    // continue关键字
    KW_BREAK,       // break关键字   
    KW_RETURN,      // return关键字
    KW_SIZEOF,      // sizeof关键字

    KW_ALIGN,       // __align关键字   
    KW_CDECL,       // __cdecl关键字 standard c call
    KW_STDCALL,     // __stdcall关键字 pascal c call

    /* 标识符 */
    TK_IDENT
};
4.2 词法分析实现
  • 首先进行初始化，即是让关键字、运算符这些特权单词，在正式词法分析之前进入单词表
  • 之后进行取单词，根据一个个字符的先后顺序，解析空白和注释、解析标识符、解析整数、判断出一个个单词
    lex.h(lexical_analysis.h):
/* 词法状态 */
enum e_LexState
{
    LEX_NORMAL,
    LEX_SEP
};

void init_lex();//词法分析初始化
void skip_white_space();//忽略空格,TAB及回车
void parse_comment();//解析注释
void preprocess();//预处理，忽略分隔符及注释
int is_nodigit(char c);//判断c是否为字母(a-z,A-Z)或下划线(-)
int is_digit(char c);//判断c是否为数字
TkWord* parse_identifier();//解析标识符
void parse_num();//解析整型常量
void parse_string(char sep);//解析字符常量、字符串常量
void get_token();//取单词

lex.c:

#include "lexical_analysis.h"

DynString tkstr;        //单词字符串
DynString sourcestr;    //单词源码字符串

char ch;        //当前取到的源码字符
int token;      //单词编码
int tkvalue;    //单词值
int line_num;   //行号


/***********************************************************
* 功能:   词法分析初始化
**********************************************************/
void init_lex()
{
    TkWord *tp;
    static TkWord keywords[] = {
    { TK_PLUS,      NULL,     "+" },
    { TK_MINUS,     NULL,     "-" },
    { TK_STAR,      NULL,     "*" },
    { TK_DIVIDE,    NULL,     "/" },
    { TK_MOD,       NULL,     "%" },
    { TK_EQ,        NULL,     "==" },
    { TK_NEQ,       NULL,     "!=" },
    { TK_LT,        NULL,     "<" },
    { TK_LEQ,       NULL,     "<=" },
    { TK_GT,        NULL,     ">" },
    { TK_GEQ,       NULL,     ">=" },
    { TK_ASSIGN,    NULL,     "=" },
    { TK_POINTSTO,  NULL,     "->" },
    { TK_DOT,       NULL,     "." },
    { TK_AND,       NULL,     "&" },
    { TK_OPENPA,    NULL,     "(" },
    { TK_CLOSEPA,   NULL,     ")" },
    { TK_OPENBR,    NULL,     "[" },
    { TK_CLOSEBR,   NULL,     "]" },
    { TK_BEGIN,     NULL,     "{" },
    { TK_END,       NULL,     "}" },
    { TK_SEMICOLON, NULL,     ";" },
    { TK_COMMA,     NULL,     "," },
    { TK_ELLIPSIS,  NULL,   "..." },
    { TK_EOF,       NULL,    "End_Of_File" },
    { TK_CINT,      NULL,       "整型常量" },
    { TK_CCHAR,     NULL,       "字符常量" },
    { TK_CSTR,      NULL,       "字符串常量" },
    { KW_CHAR,      NULL,       "char" },
    { KW_SHORT,     NULL,       "short" },
    { KW_INT,       NULL,       "int" },
    { KW_VOID,      NULL,       "void" },
    { KW_STRUCT,    NULL,       "struct" },
    { KW_IF,        NULL,       "if" },
    { KW_ELSE,      NULL,       "else" },
    { KW_FOR,       NULL,       "for" },
    { KW_CONTINUE,  NULL,       "continue" },
    { KW_BREAK,     NULL,       "break" },
    { KW_RETURN,    NULL,       "return" },
    { KW_SIZEOF,    NULL,       "sizeof" },
    { KW_ALIGN,     NULL,       "__align" },
    { KW_CDECL,     NULL,       "__cdecl" },
    { KW_STDCALL,   NULL,       "__stdcall" },
    { 0,            NULL,       NULL }
    };

    dynarray_init(&tktable, 8);
    for (tp = &keywords[0]; tp->spelling != NULL; tp++)
    {
        tkword_direct_insert(tp);
    }
}

/***********************************************************
*  功能:  忽略空格,TAB及回车
**********************************************************/
void skip_white_space()
{
    while (ch == ' ' || ch == '\t' || ch == '\r')
    {
        if (ch == '\r')
        {
            getch();
            if (ch != '\n')
                return;
            line_num++;
        }
        printf("%c", ch);
        getch();
    }
}

/***********************************************************
*  功能:  解析注释
**********************************************************/
void parse_comment()
{
    getch();
    do
    {
        do
        {
            if (ch == '\n' || ch == '*' || ch == CH_EOF)
                break;
            else
                getch();
        } while (1);
        if (ch == '\n')
        {
            line_num++;
            getch();
        }
        else if (ch == '*')
        {
            getch();
            if (ch == '/')
            {
                getch();
                return;
            }
        }
        else
        {
            error("一直到文件尾未看到配对的注释结束符");
            return;
        }
    } while (1);
}

/***********************************************************
*  功能:  预处理，忽略分隔符及注释
**********************************************************/
void preprocess()
{
    while (1)
    {
        if (ch == ' ' || ch == '\t' || ch == '\r')
            skip_white_space();
        else if (ch == '/')
        {
            //向前多读一个字节看是否是注释开始符，猜错了把多读的字符再放回去
            getch();
            if (ch == '*')
            {
                parse_comment();
            }
            else
            {
                ungetc(ch, fin); //把一个字符退回到输入流中
                ch = '/';
                break;
            }
        }
        else
            break;
    }
}

/***********************************************************
* 功能:   判断c是否为字母(a-z,A-Z)或下划线(-)
* c:        字符值
**********************************************************/
int is_nodigit(char c)
{
    return (c >= 'a'  && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
}

/***********************************************************
* 功能:   判断c是否为数字
* c:        字符值
**********************************************************/
int is_digit(char c)
{
    return c >= '0'&&c <= '9';
}

/***********************************************************
* 功能:   解析标识符
**********************************************************/
TkWord* parse_identifier()
{
    dynstring_reset(&tkstr);
    dynstring_chcat(&tkstr, ch);
    getch();
    while (is_nodigit(ch) || is_digit(ch))
    {
        dynstring_chcat(&tkstr, ch);
        getch();
    }
    dynstring_chcat(&tkstr, '\0');
    return tkword_insert(tkstr.data);
}

/***********************************************************
* 功能:   解析整型常量
**********************************************************/
void parse_num()
{
    dynstring_reset(&tkstr);
    dynstring_reset(&sourcestr);
    do {
        dynstring_chcat(&tkstr, ch);
        dynstring_chcat(&sourcestr, ch);
        getch();
    } while (is_digit(ch));
    if (ch == '.')
    {
        do {
            dynstring_chcat(&tkstr, ch);
            dynstring_chcat(&sourcestr, ch);
            getch();
        } while (is_digit(ch));
    }
    dynstring_chcat(&tkstr, '\0');
    dynstring_chcat(&sourcestr, '\0');
    tkvalue = atoi(tkstr.data);

}

/***********************************************************
* 功能:   解析字符常量、字符串常量
* sep:      字符常量界符标识为单引号(')
字符串常量界符标识为双引号(")
**********************************************************/
void parse_string(char sep)
{
    char c;
    dynstring_reset(&tkstr);
    dynstring_reset(&sourcestr);
    dynstring_chcat(&sourcestr, sep);
    getch();
    for (;;)
    {
        if (ch == sep)
            break;
        else if (ch == '\\')
        {
            dynstring_chcat(&sourcestr, ch);
            getch();
            switch (ch) //解析转义字符
            {
            case '0':
                c = '\0';
                break;
            case 'a':
                c = '\a';
                break;
            case 'b':
                c = '\b';
                break;
            case 't':
                c = '\t';
                break;
            case 'n':
                c = '\n';
                break;
            case 'v':
                c = '\v';
                break;
            case 'f':
                c = '\f';
                break;
            case 'r':
                c = '\r';
                break;
            case '\"':
                c = '\"';
                break;
            case '\'':
                c = '\'';
                break;
            case '\\':
                c = '\\';
                break;
            default:
                c = ch;
                if (c >= '!'&&c < '~')
                    warning("非法转义字符：\'\\%c\'", c);
                else
                    warning("非法转义字符：\'\\0x%x\'", c);
                break;
            }
            dynstring_chcat(&tkstr, c);
            dynstring_chcat(&sourcestr, ch);
            getch();
        }
        else
        {
            dynstring_chcat(&tkstr, ch);
            dynstring_chcat(&sourcestr, ch);
            getch();
        }
    }
    dynstring_chcat(&tkstr, '\0');
    dynstring_chcat(&sourcestr, sep);
    dynstring_chcat(&sourcestr, '\0');
    getch();
}

/***********************************************************
*  功能:  取单词
**********************************************************/
void get_token()
{
    preprocess();
    switch (ch)
    {
    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
    case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
    case 'o': case 'p': case 'q': case 'r': case 's': case 't':
    case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
    case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
    case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T':
    case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
    case '_':
    {
        TkWord* tp;
        tp = parse_identifier();
        token = tp->tkcode;
        break;
    }
    case '0': case '1': case '2': case '3':
    case '4': case '5': case '6': case '7':
    case '8': case '9':
        parse_num();
        token = TK_CINT;
        break;
    case '+':
        getch();
        token = TK_PLUS;
        break;
    case '-':
        getch();
        if (ch == '>')
        {
            token = TK_POINTSTO;
            getch();
        }
        else
            token = TK_MINUS;
        break;
    case '/':
        token = TK_DIVIDE;
        getch();
        break;
    case '%':
        token = TK_MOD;
        getch();
        break;
    case '=':
        getch();
        if (ch == '=')
        {
            token = TK_EQ;
            getch();
        }
        else
            token = TK_ASSIGN;
        break;
    case '!':
        getch();
        if (ch == '=')
        {
            token = TK_NEQ;
            getch();
        }
        else
            error("暂不支持'!'(非操作符)");
        break;
    case '<':
        getch();
        if (ch == '=')
        {
            token = TK_LEQ;
            getch();
        }
        else
            token = TK_LT;
        break;
    case '>':
        getch();
        if (ch == '=')
        {
            token = TK_GEQ;
            getch();
        }
        else
            token = TK_GT;
        break;
    case '.':
        getch();
        if (ch == '.')
        {
            getch();
            if (ch != '.')
                error("省略号拼写错误");
            else
                token = TK_ELLIPSIS;
            getch();
        }
        else
        {
            token = TK_DOT;
        }
        break;
    case '&':
        token = TK_AND;
        getch();
        break;
    case ';':
        token = TK_SEMICOLON;
        getch();
        break;
    case ']':
        token = TK_CLOSEBR;
        getch();
        break;
    case '}':
        token = TK_END;
        getch();
        break;
    case ')':
        token = TK_CLOSEPA;
        getch();
        break;
    case '[':
        token = TK_OPENBR;
        getch();
        break;
    case '{':
        token = TK_BEGIN;
        getch();
        break;
    case ',':
        token = TK_COMMA;
        getch();
        break;
    case '(':
        token = TK_OPENPA;
        getch();
        break;
    case '*':
        token = TK_STAR;
        getch();
        break;
    case '\'':
        parse_string(ch);
        token = TK_CCHAR;
        tkvalue = *(char *)tkstr.data;
        break;
    case '\"':
    {
        parse_string(ch);
        token = TK_CSTR;
        break;
    }
    case EOF:
        token = TK_EOF;
        break;
    default:
        error("不认识的字符:\\x%02x", ch); //上面字符以外的字符，只允许出现在源码字符串，不允许出现的源码的其它位置
        getch();
        break;
    }
}

5. 控制程序

包括主函数,初始化程序、着色程序和cleanup扫尾清理

lexical_analysis.h:

void getch();//从源文件中读取一个字符

extern TkWord* tk_hashtable[MAXKEY];// 单词哈希表
extern DynArray tktable;            // 单词动态数组
extern DynString tkstr;     //单词字符串
extern DynString sourcestr; //单词源码字符串

extern char ch;     //当前取到的源码字符
extern int token;       //单词编码
extern int tkvalue; //单词值
extern int line_num;    //行号

extern FILE *fin;
extern char *filename;
extern char *outfile;

lexical_analysis.c:

#include "lexical_analysis.h"

FILE *fin = NULL;
char *filename;
char *outfile;

/***********************************************************
* 功能:   词法着色
**********************************************************/
void color_token(int lex_state)
{
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    char *p;
    switch (lex_state)
    {
    case LEX_NORMAL:
    {
        if (token >= TK_IDENT)
            SetConsoleTextAttribute(h, FOREGROUND_INTENSITY);
        else if (token >= KW_CHAR)
            SetConsoleTextAttribute(h, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
        else if (token >= TK_CINT)
            SetConsoleTextAttribute(h, FOREGROUND_RED | FOREGROUND_GREEN);
        else
            SetConsoleTextAttribute(h, FOREGROUND_RED | FOREGROUND_INTENSITY);
        p = get_tkstr(token);
        printf("%s", p);
        break;
    }
    case LEX_SEP:
        printf("%c", ch);
        break;
    }
}

/***********************************************************
*  功能:  词法分析测试
**********************************************************/
void test_lex()
{
    do
    {
        get_token();
        color_token(LEX_NORMAL);
    } while (token != TK_EOF);
    printf("\n代码行数: %d行\n", line_num);
}


/***********************************************************
* 功能:   初始化
**********************************************************/
void init()
{
    line_num = 1;
    init_lex();
}


/***********************************************************
* 功能:   扫尾清理工作
**********************************************************/
void cleanup()
{
    int i;
    for (i = TK_IDENT; i < tktable.count; i++)
    {
        free(tktable.data[i]);
    }
    free(tktable.data);
}

/***********************************************************
* 功能:   得到文件扩展名
* fname:    文件名称
**********************************************************/
char *get_file_ext(char *fname)
{
    char *p;
    p = strrchr(fname, '.');
    return p + 1;
}
/***********************************************************
* 功能:   从源文件中读取一个字符
**********************************************************/
void getch()
{
    ch = getc(fin);
}


/***********************************************************
* 功能:   main主函数
**********************************************************/
int main(int argc, char ** argv)
{

    fin = fopen(argv[1], "rb");
    system("pause");
    if (!fin)
    {
        printf("不能打开SC源文件!\n");
        return 0;
    }
    init();
    getch();
    test_lex();
    cleanup();
    fclose(fin);
    printf("%s 词法分析成功!", argv[1]);
    system("pause");
    return 1;
}

测试

测试代码：

/*********************************************************** 
 * color_token_demo.c
 **********************************************************/
struct  point
{
    int  x;  
    int  y;
};
void  main()
{
    int  arr[10]; 
    int  i; 
    struct  point  pt;
    pt.x =1024;
    pt.y=768;
    for(i = 0; i < 10; i = i + 1)   
    {
        arr[i]=i;           
        if (i == 6)
        {
            continue;       
        }
        else
        {
            printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
    printf("pt.x = %d, pt.y = %d\n",pt.x,pt.y);
}

结果：
这里写图片描述

Zach_z
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理动手实操：词法解析算法的一些概念说明
tyler_download的专栏
03-16 3812
大家好，欢迎大家来到Coding迪斯尼，在深入探究词法解析算法前，我们需要了解一些基本概念。了解基本概念有点像背单词，它有些无聊，但你又不得不做。好在这类事情在我们的课程里不多。大家过过眼，留个心眼就好。 阅读博客的朋友可以到我的网易云课堂中，通过视频的方式查看代码的调试和执行过程：   http://study.163.com/course/courseMain.htm?cou
编译原理实验1-词法分析器实现
weixin_45428457的博客
02-23 1235
编译原理，词法分析
词法分析器的设计与实现--编译原理操作步骤，1、你的算法工作流程图； 2、你的函数流程图；3，具体代码
最新发布
weixin_69491512的博客
05-31 677
在进行实验之前要先通过自己画出的程序的流程图，一步一步的优化自己的编程流程，可以在自己脑海中形成清晰的框架，确保不会出现一些大的方向上的判断错误，更有利于后续代码的书写以及实验的进行。对于我今后对编译原理的学习有很大的帮助。词法分析是编译程序进行编译时第一个要进行的任务，主要是对源程序进行编译预处理之后，对整个源程序进行分解，分解成一个个单词，这些单词有且只有五类，分别时标识符、关键字（保留字）、常数、 运算符 、界符。（注：代码是之前粘的别的博主的，因为我也不会写，流程图等是自己写的，互相借鉴）
编译原理三：词法分析
to_the_Future的博客
06-29 612
在编译器工作流程中，词法分析是将分解为一系列的过程。词法单元包括等。词法分析器会预定义的。词法分析器通常使用来实现。有限状态机是一种计算模型，它可以接受一串输入并根据一组状态转移规则进行状态转移，最终输出一个结果。在词法分析器中，有限状态机通常用于匹配输入的字符串。词法分析器可以，并且不需要回溯的操作，因此能够地编译器的词法分析。词法分析器通常是，它会将源代码分解为一系列，然后将这些词法单元传递给语法分析器进行语法分析。词法分析器的设计和实现对编译器的性能和正确性都有重要的影响。
编译原理-词法分析器
weixin_61426225的博客
10-24 2795
我们考虑转换到状态1的条件：我们只有在接收到字符a的时候才会转换成状态1，而想要从状态1转换的状态3则必须要再接收一个字符a，考虑状态2，只有在接收到字符b的情况下才会转换到状态2，然后终态一定是以aa或bb结尾吗？我们看到终态还可以接收a|b转圈，所以一定不是以aa|bb结尾，但是要想从初态到终态，一定会经过1、2两个状态中的一个，所以一定会出现连续的aa|bb。这一步进行的意义是将状态之间的转换，变为状态集之间的转换，这样就有可能消除映射不是单值部分映射的问题。
编译器的实现 词法+语法
06-21
编译器的实现 词法+语法 编译器的实现 词法+语法 编译器的实现 词法+语法
编译器-词法分析、语法分析 、语义分析.zip
04-17
编译器的工作过程可以分为几个主要阶段，包括词法分析、语法分析和语义分析，这些阶段在编译器设计中扮演着关键角色。 **词法分析（Lexical Analysis）** 词法分析是编译器的第一步，它处理源代码的字符流，将源...
C--编译器 flex 词法分析器
03-18
Linux下的flex词法分析器实验要求： 熟练掌握词法分析，设计编译程序能够查出 C--源代码中可能包含的下 述几类错误: 1. 词法错误(错误类型 A):出现 C—词法中未定义的字符以及任何不符合 C—词法单元定义的字符; 2. ...
C-minus词法&语法分析简易编译器源码
03-15
【编译原理课设】C-minus词法&语法分析的简易编译器源码，用C语言实现。
编译器-2021-spring
03-04
前端处理源代码，包括词法分析、语法分析、语义分析和中间代码生成。后端则涉及目标代码优化和机器码生成。这一过程确保了源代码的逻辑被正确地转换为针对特定架构的机器语言。 2. **词法分析** 这是编译器的第一...
kpd：使用D编写的Krug的旧编译器-原型版本
01-31
它的标准库包括了用于编译器开发的工具，如正则表达式、词法分析器和语法解析器的库，这使得D语言成为构建编译器的理想选择。 2. **编译器架构**：kpd可能采用了经典的编译器设计，包括词法分析、语法分析、语义...
链接器与加载器 linker and loader
03-19
Linker and Loader (链接器与加载器)是一本深入描述程序的生成与加载过程以及程序与操作系统关系的书，对程序员提升专业素质大有裨益。
编译器（词法分析，语法分析）
01-04
学长我可是花了好长时间写出来的啊，学长很好吧。编译原理词法+语法（对for语句分析产生四元式），LL1。反正学长答辩90分轻松掠过。学长只能帮你到这了
编译器之词法分析
weixin_34297704的博客
04-17 356
最近我们在做一个有关SNL语言的编译器，下面写了一下大概流程 词法分析器是编译过程的第一阶段，功能是 1.对以字符串形式输入的源程序（这里是把源程序从文件读出，也可以在控制台输入）按顺序进行扫描，根据SNL语言的词法规则识别具有独立意义的单词（符号）序列， 如保留字（由语言系统自身定义的，通常是由字母组成的字符串）， 标识符（一般是由字母开头，字母、数字，或其它符号的任意组合构成的，...
动手实现编译器（一）——词法分析
qq_34851605的博客
06-11 1407
第一部分：词法分析 我们从一个简单的词法分析器开始我们的编译器编写。词法分析器的工作是依次扫视字符串形式源程序中的各个字符，逐个识别出其中的单词，并将其转换为内部编码形式的单词符号串作确为输出。 从简单的单词开始： 五个基本的数学运算符（*，/，+，-，% ）和十进制整数（0…9） 扫描到的每个单词都将存储在此结构中： // 单词结构体 struct token { int token; int intvalue; }; 其中 token 字段可以为以下值之一： enum { T_ADD, T_
高级语言的编译过程和解释过程_编译过程简述
weixin_39582708的博客
12-04 5224
前面的文章中我们简单介绍了高级语言的五大语法元素，以及这些语法元素是如何构成表达式，构成语句最终构成可执行的代码的。我们也简单介绍了一些编程范式，可以写出'人能读懂的代码'了。那么机器是怎么'读'我们的代码的呢？我们称机器'读'我们的代码的过程为代码的编译。机器'读懂'我们用高级语言编写的代码可以大致分为两个阶段：分析我们的代码，明白代码的意图。把高级语言代码映射成目标语言。帮助机器读我...
编译器----语法分析
热门推荐
Zach_z的博客
05-29 1万+
本文通过学习王博俊、张宇的《DIY Compiler and Linker》 ，实现词法分析器，一方面作为自己的学习笔记，一方面也作与大家分享与交流 一、语法分析的任务 语法分析任务是在词法分析识别出单词符号的基础上，分析源程序的语法结构，即分析由这些单词如何组成各种语法成分，比如“声明”、“函数”、“语句”、“表达式”等，并分析判断程序的语法结构是否复合语法规则。 语法分析分为自上而下和自...
编译原理 - 词法分析
Mafia的博客
03-11 1514
词法分析词法分析器作用编译过程划分为词法分析和语法分析两个阶段的原因语法分析中的三个概念词法分析的实现如何区分兼容性的标识符词法分析算法词法单元词法单元例子词法单元的模式正则表达式用正则语言描述字符串的集合 正则表达式是一种可以很方便地描述词素模式的方法。 如何对正则表达式进行转换：首先转换为不确定有穷自动机，然后再转换为确定有穷自动机。 后两种表示方法可以作为一个“驱动程序”的输入。 这个驱动程序就是一段模拟这些自动机的代码，它使用这些自动机来确定下一个词法单元。 这个驱动程序以及对自动机的规约形成了词法
C++ Compiler 和 Linker 在 Visual Studio中
lsh的博客
06-13 939
编译和关联linker的相关概念。 主要三个概念，头文件、库（lib, dll）, 业务逻辑代码 在visual Studio 中，ctr+F7， 是只进行编译，编译只在于审查业务逻辑代码，和头文件是否匹配，不验证是否在库文件中有实现。 外来的cpp组件，一般包含include 和 libs两个文件夹。 include 内，为我们所需的头文件，需要在visual studio 的属性>c++>general 中添加位置 lib内为下文说的 库文件，需要在visual studio 的属性&gt
C-Minus词法分析和语法分析设计编译器编译原理课程设计
05-18
"C-Minus编译器的词法分析和语法分析是编译原理课程设计的重点内容。这个设计任务要求学生构建一个简单的C-Minus编译器，仅包含词法分析器（scanner）和语法分析器（parser）。在设计过程中，主要关注点在于理解和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值