词法分析器 c语言

最新推荐文章于 2024-04-28 19:33:22 发布
最新推荐文章于 2024-04-28 19:33:22 发布
阅读量977 收藏 3
点赞数 1
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/biglxl/article/details/75223235
版权

直接撸代码

#include <stdio.h>  
#include <string.h>  
#define BUFSIZE 256  

static char keyWords[][13]={"abstract", "boolean", "break", "byte", "case", "catch", "char",   
       "class", "const", "continue", "default", "do", "double", "else", "extends", "false",   
       "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof",   
       "int", "interface", "long", "native", "new", "null", "package", "private", "protected",   
       "public", "return", "short", "static", "super", "switch", "synchronized", "this",   
       "throw", "throws", "transient", "true", "try", "void", "volatile", "while"};      /*关键字 50个*/   
FILE *fin;                                     /*要处理的java文件*/   
FILE *fout;                                    /*保存处理结果的文件*/     
char filePath[100];                            /*要处理的java文件路径*/   
char savePath[100] = "javascan_result.txt";            /*保存处理结果文件的路径*/   
char inBuf[2][BUFSIZE];                        /*输入缓冲区*/  
char scanBuf[BUFSIZE];                         /*扫描缓冲区*/   
int bufNum = 0;                                /*输入缓冲区编号*/  
long totalWords = 0;                           /*总单词数量*/  
long lineWords = 0;                            /*单行单词个数*/  
long lineCount = 0;                            /*记录行数*/  

void dealWord();                               /*词法分析*/   
void clearNote();                              /*过滤注释及多余空格*/  
void getWords(int state);                      /*解析获取单词*/  
void getWordKind(char str[]);                  /*获取单词类型*/  
int getCharKind(char c);                       /*判断字符类型*/  
int isOper(char c);                            /*判断是否为可消除空格的字符*/  
int isWord(char c);                            /*判断是否为字母*/  
int isKeyWord(char str[]);                     /*判断是否为关键字*/  
int isSignWord(char str[]);                    /*判断是否为标识符*/  
int isNumber(char c);                          /*判断是否为数字*/  
int isInteger(char str[]);                     /*判断是否为整型*/  
int isFloat(char str[]);                       /*判断是否为浮点型*/  

int main()  
{  
    /*printf("Please set the path of the Java File that you want to analyse:");*/  
    printf("请设置要分析的Java程序文件的路径：");  
    scanf("%s", filePath);  
    if((fin = fopen(filePath, "r")) == NULL)  
    {  
        printf("Can't open this file!\n");  
        return 0;  
    }  
    if((fout = fopen(savePath, "w")) == NULL)  
    {  
        printf("Can't write to this file!\n");  
        return 0;  
    }  
    fprintf(fout, "Java词法分析器 Powered By Hamvorinf \n------------------------------------------------------\n");  
    dealWord();  
    fprintf(fout, "------------------------------------------------------\n分析结束！\n");  
    fclose(fin);  
    fclose(fout);  
    system("pause");  
    return 0;  
}  

/*******************词法分析*******************/   
void dealWord()  
{  
    char c;  
    int i, j, k;  
    int count = 0;  
    int chgLine = 0;            /*换行标志*/  

    /*循环读取字符*/  
    while(1)  
    {  
        c = fgetc(fin);  
        if(c == EOF)  
        {  
            break;  
        }  
        /*如果是换行符*/  
        if(c == '\n' || count == BUFSIZE - 2)  
        {  
            /*如果长度超出，则放入对半互补区*/  
            if(count == BUFSIZE - 2)  
            {  
                inBuf[bufNum][count] = c;  
                for(i = count; i > 0; i--)  
                {  
                    if(isOper(inBuf[bufNum][i]) == 1)  
                    {  
                        for(j = 0, k = i+1; k <= count; k++, j++)  
                        {  
                            inBuf[1-bufNum][j] = inBuf[bufNum][k];  
                        }  
                        inBuf[1-bufNum][j] = '\0';  
                        inBuf[bufNum][i+1] = '\0';  
                    }  
                }  
            }  
            else  
            {  
                inBuf[bufNum][count] = '\0';  
            }  

            /*若一行读取完毕，将换行标志置为1*/  
            if(c == '\n')  
            {  
                chgLine = 1;  
                lineCount++;  
            }  

            clearNote(inBuf[bufNum]);   /*过滤注释和多余空格、制表符*/  

            /*分析处理*/  
            if(strlen(inBuf[bufNum]) > 0)  
            {  
                /*将数据从输入缓冲区拷贝如扫描缓冲区*/  
                strcpy(scanBuf, inBuf[bufNum]);  

                /*对扫描缓冲区进行词语分析处理*/  
                getWords(0);  
            }  

            /*如果长度超出，启用对半互补区*/  
            if(count == BUFSIZE - 2)  
            {  
                bufNum = 1 - bufNum;  
            }  

            /*一行处理完毕输出当行单词数*/  
            if(chgLine == 1)  
            {  
                printf("第%-4ld行共有 %-4ld个单词.\n", lineCount, lineWords);  
                chgLine = 0;  
                lineWords = 0;  
            }  

            count = 0;  
        }  
        else  
        {  
            inBuf[bufNum][count++] = c;  
        }  
    }  
    printf("共处理了 %-4ld行的 %-4ld个单词\n", lineCount, totalWords);  
    printf("处理结果已经保存到 %s 下！\n", savePath);  
}  

/*******************过滤注释及多余空格*******************/   
void clearNote()  
{  
    int i, j, k;  
    int noteCount = 0;  
    int flag = 0;           /*是否是字符串*/  
    char note[100];  

    /*去除注释*/  
    for(i = 0; inBuf[bufNum][i] != '\0'; i++)  
    {  
        if(inBuf[bufNum][i] == '"')  
        {  
            flag = 1 - flag;  
            continue;  
        }  
        if(inBuf[bufNum][i] == '/' && flag == 0)  
        {  
            /*如果是“//”注释*/  
            if(inBuf[bufNum][i+1] == '/')  
            {  
                for(j = i; inBuf[bufNum][j] != '\0'; j++)  
                {  
                    note[noteCount++] = inBuf[bufNum][j];  
                }  
                note[noteCount] = '\0';  
                noteCount = 0;  
                lineWords++;  
                fprintf(fout, "%4ld.%-4ld  【%s】     【注释】---【0x101】\n",lineCount, lineWords, note);  
                inBuf[bufNum][i] = '\0';  
                break;  
            }  

            if(inBuf[bufNum][i+1] == '*')  
            {  
                note[noteCount++] = '/';  
                note[noteCount++] = '*';  
                for(j = i+2; inBuf[bufNum][j] != '\0'; j++)  
                {  
                    note[noteCount++] = inBuf[bufNum][j];  
                    if(inBuf[bufNum][j] == '*' && inBuf[bufNum][j+1] == '/')  
                    {  
                        j += 2;  
                        note[noteCount++] = inBuf[bufNum][j];  
                        note[noteCount] = '\0';  
                        noteCount = 0;  
                        lineWords++;  
                        fprintf(fout, "%4ld.%-4ld  【%s】     【注释】---【0x101】\n",lineCount, lineWords, note);  
                        break;  
                    }  
                }  
                for(; inBuf[bufNum][j] != '\0'; j++, i++)  
                {  
                    inBuf[bufNum][i] = inBuf[bufNum][j];  
                }  
                if(inBuf[bufNum][j] == '\0')  
                {  
                    inBuf[bufNum][i] = '\0';  
                }  
            }  
        }  
    }  

    /*去除多余空格*/  
    for(i = 0, flag = 0; inBuf[bufNum][i] != '\0'; i++)  
    {  
        if(inBuf[bufNum][i] == '"')  
        {  
            flag = 1 - flag;  
            continue;  
        }  
        if(inBuf[bufNum][i] == ' ' && flag == 0)  
        {  
            for(j = i+1; inBuf[bufNum][j] != '\0' && inBuf[bufNum][j] == ' '; j++)  
            {  
            }  
            if(inBuf[bufNum][j] == '\0')  
            {  
                inBuf[bufNum][i] = '\0';  
                break;  
            }  
            if(inBuf[bufNum][j] != '\0' && ((isOper(inBuf[bufNum][j]) == 1) || (i > 0 && isOper(inBuf[bufNum][i-1]) == 1)))  
            {  
                for(k = i; inBuf[bufNum][j] != '\0'; j++, k++)  
                {  
                    inBuf[bufNum][k] = inBuf[bufNum][j];  
                }  
                inBuf[bufNum][k] = '\0';  
                i--;  
            }  
        }  
    }  

    /*去除多余制表符*/  
    for(i = 0, flag = 0; inBuf[bufNum][i] != '\0'; i++)  
    {  
        if(inBuf[bufNum][i] == '\t')  
        {  
            for( j = i; inBuf[bufNum][j] != '\0'; j++)  
            {  
                inBuf[bufNum][j] = inBuf[bufNum][j+1];  
            }  
            i = -1;  
        }  
    }  
}  



/*******************判断是否为可消除空格的字符/操作符*******************/  
int isOper(char c)  
{  
    if((c > 'z' || (c < 'a' && c > 'Z') || (c < 'A' && c > '9') || (c < '0')) && c != '_' && c != '$')  
    {  
        return 1;  
    }  
    return 0;  
}  


/*******************判断是否为字母*******************/  
int isWord(char c)  
{  
    if((c <= 'z' && c >= 'a') || (c <= 'Z' && c >= 'A'))  
    {  
        return 1;  
    }  
    return 0;  
}  

/*******************判断是否为数字*******************/  
int isNumber(char c)  
{  
    if(c <= '9' && c >= '0')  
    {  
        return 1;  
    }  
    return 0;  
}  

/*******************判断是否为整型*******************/  
int isInteger(char str[])  
{  
    int i;  
    if(str[0] == '-' || isNumber(str[0]) == 1)  
    {  
        for(i = 0; i < strlen(str); i++)  
        {  
            if(str[i] == '.')  
            {  
                return 0;  
            }  
            if((str[i] == 'x' || str[i] == 'X') && (((str[0] == '-' || str[0] == '+') && (str[1] != '0' || i > 2)) || (str[0] != '-' && str[0] != '+' && (str[0] != '0' || i > 1))))  
            {  
                return 0;  
            }  
            if((i < strlen(str) -1) && isNumber(str[i]) == 0 && str[i] != 'x' && str[i] != 'X')  
            {  
                if(strlen(str) > 2 && strnicmp("0x", str, 2) == 0 || strnicmp("-0x", str, 3) == 0)  
                {  
                    if(str[i] >= 'A' && str[i] <= 'F')  
                    {  
                        continue;  
                    }  
                }  
                return 0;  
            }  
            if((i == strlen(str) - 1) && isNumber(str[i]) ==0 && str[i] != 'L')  
            {  
                if(strlen(str) > 2 && strnicmp("0x", str, 2) == 0 || strnicmp("-0x", str, 3) == 0)  
                {  
                    if(str[i] >= 'A' && str[i] <= 'F')  
                    {  
                        continue;  
                    }  
                }  
                return 0;  
            }  
        }  
        return 1;     
    }  
    return 0;  
}  
/*******************判断是否为浮点型*******************/  
int isFloat(char str[])  
{  
    int i;  
    int flag = 0;  
    if(str[0] == '-' || isNumber(str[0]) == 1)  
    {  
        for(i = 0; i < strlen(str); i++)  
        {  
            if(str[i] == '.')  
            {  
                if(flag == 0)  
                {  
                    flag = 1;  
                    continue;  
                }  
                else  
                {  
                    return 0;  
                }  
            }  
            if((str[i] == 'x' || str[i] == 'X') && (((str[0] == '-' || str[0] == '+') && (str[1] != '0' || i > 2)) || (str[0] != '-' && str[0] != '+' && (str[0] != '0' || i > 1))))  
            {  
                return 0;  
            }  
            if(isNumber(str[i]) == 0 && str[i] != 'x' && str[i] != 'X')  
            {  
                if(strlen(str) > 2 && strnicmp("0x", str, 2) == 0 || strnicmp("-0x", str, 3) == 0)  
                {  
                    if(str[i] >= 'A' && str[i] <= 'F')  
                    {  
                        continue;  
                    }  
                }  
                return 0;  
            }  
        }  
        return flag;      
    }  
    return 0;  
}  
/*******************判断字符类型*******************/  
int getCharKind(char c)  
{  
    /*是字母*/  
    if(isWord(c) == 1)  
    {  
        return 1;  
    }  
    /*是数字*/  
    if(isNumber(c) == 1)  
    {  
        return 2;  
    }  
    /*是$或_*/  
    if(c == '$' || c == '_')  
    {  
        return 3;  
    }  
    /*是转义字符*/  
    if(c == '\\')  
    {  
        return 4;  
    }  
    /*是等号*/  
    /*if(c == '=') 
    { 
        return 5; 
    }*/  
    return 0;  
}  
/*******************判断是否为关键字*******************/  
int isKeyWord(char str[])  
{  
    int i;  
    for(i = 0; i < 50; i++)  
    {  
        if(strcmp(str, keyWords[i]) == 0)  
        {  
            return 1;  
        }  
    }  
    return 0;  
}  
/*******************判断是否为标识符*******************/  
int isSignWord(char str[])  
{  
    int i;  
    if(str[0] == '$' || str[0] == '_' || isWord(str[0]) == 1)  
    {  
        for(i = 0; str[i] != '\0'; i++)  
        {  
            if(isOper(str[i]) == 1)  
            {  
                return 0;  
            }  
        }  
        return 1;  
    }  
    return 0;  
}  
/*******************获取单词类型*******************/  
void getWordKind(char str[])  
{  
    int i, j, k;  
    int flag = 0;  

    /*判断是否为关键字或标识符*/  
    if(isKeyWord(str) == 1)  
    {  
        if(strcmp(str,"true") == 0 || strcmp(str,"false") == 0)  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【布尔型】---【0x105】\n",lineCount, lineWords, str);  
        }  
        else  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【关键字】---【0x103】\n",lineCount, lineWords, str);  
        }  
    }  
    else if(isSignWord(str) == 1)  
    {  
        fprintf(fout, "%4ld.%-4ld  【%s】     【标识符】---【0x104】\n",lineCount, lineWords, str);  
    }  
    else if(isInteger(str) == 1)  
    {  
        fprintf(fout, "%4ld.%-4ld  【%s】     【整型】---【0x107】\n",lineCount, lineWords, str);  
    }  
    else if(isFloat(str) == 1)  
    {  
        fprintf(fout, "%4ld.%-4ld  【%s】     【浮点型】---【0x108】\n",lineCount, lineWords, str);  
    }  
    else if(str[0] == '\'' && str[strlen(str)-1] == '\'')  
    {  
        fprintf(fout, "%4ld.%-4ld  【%s】     【字符型】---【0x106】\n",lineCount, lineWords, str);  
    }  
    else if(str[0] == '"' && str[strlen(str)-1] == '"')  
    {  
        fprintf(fout, "%4ld.%-4ld  【%s】     【字符串】---【0x109】\n",lineCount, lineWords, str);  
    }  
    else if(isOper(str[0]) == 1 && str[0] != '"' && str[0] != '\'')  
    {  
        if(strcmp(str, "<") == 0 || strcmp(str, ">") == 0 || strcmp(str, "<=") == 0 || strcmp(str, ">=") == 0)  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【< > <= >=】---【0x118】\n",lineCount, lineWords, str);      
        }  
        else if(strcmp(str, "<<") == 0 || strcmp(str, ">>") == 0 || strcmp(str, ">>>") == 0 || strcmp(str, "<<<") == 0)  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【<< >> <<< >>>】---【0x119】\n",lineCount, lineWords, str);    
        }  
        else if(strchr(str, '=') != NULL)  
        {  
            if(strcmp(str, "==") == 0 || strcmp(str, "!=") == 0)  
            {  
                fprintf(fout, "%4ld.%-4ld  【%s】     【== !=】---【0x117】\n",lineCount, lineWords, str);      
            }  
            else  
            {  
                /*fprintf(fout, "%4ld.%-4ld  【%s】     【= += -= *= /= %%= &= ^= |= >>= <<= >>>= <<<=】---【0x110】\n",lineCount, lineWords, str);*/  
                fprintf(fout, "%4ld.%-4ld  【%s】     【特殊符号】---【0x110】\n",lineCount, lineWords, str);  
            }  
        }  
        else if(strcmp(str, "||") == 0)  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【||】---【0x112】\n",lineCount, lineWords, str);  
        }  
        else if(strcmp(str, "&&") == 0)  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【&&】---【0x113】\n",lineCount, lineWords, str);  
        }  
        else if(strcmp(str, "++") == 0 || strcmp(str, "--") == 0 || strcmp(str, "!") == 0 || strcmp(str, "~") == 0)  
        {  
            fprintf(fout, "%4ld.%-4ld  【%s】     【++ -- +(正) -(负) ! ~】---【0x11c】\n",lineCount, lineWords, str);  
        }  
        else if(strlen(str) == 1)  
        {  
            switch(str[0])  
            {  
                case '?': case ':': fprintf(fout, "%4ld.%-4ld  【%s】     【? :】---【0x111】\n",lineCount, lineWords, str); break;  
                case ' ': fprintf(fout, "%4ld.%-4ld  【%s】     【空格】---【0x102】\n",lineCount, lineWords, str); break;  
                case '{':case '}': fprintf(fout, "%4ld.%-4ld  【%s】     【{}】---【0x121】\n",lineCount, lineWords, str); break;  
                case '[':case ']':case '(':case ')':case '.': fprintf(fout, "%4ld.%-4ld  【%s】     【[]().】---【0x11d】\n",lineCount, lineWords, str); break;  
                case ',': fprintf(fout, "%4ld.%-4ld  【%s】     【,】---【0x120】\n",lineCount, lineWords, str); break;  
                case ';': fprintf(fout, "%4ld.%-4ld  【%s】     【;】---【0x122】\n",lineCount, lineWords, str); break;  
                case '+':case '-': fprintf(fout, "%4ld.%-4ld  【%s】     【+ -】---【0x11a】\n",lineCount, lineWords, str); break;  
                case '*':case '/':case '%': fprintf(fout, "%4ld.%-4ld  【%s】     【* / %%】---【0x11b】\n",lineCount, lineWords, str); break;  
                case '|': fprintf(fout, "%4ld.%-4ld  【%s】     【|】---【0x114】\n",lineCount, lineWords, str); break;  
                case '^': fprintf(fout, "%4ld.%-4ld  【%s】     【^】---【0x115】\n",lineCount, lineWords, str); break;  
                case '&': fprintf(fout, "%4ld.%-4ld  【%s】     【&】---【0x116】\n",lineCount, lineWords, str); break;  
                default: fprintf(fout, "%4ld.%-4ld  【%s】     【其他符号】---【0x999】\n",lineCount, lineWords, str); break;  
            }  
        }  
    }  
    else  
    {  
        fprintf(fout, "%4ld.%-4ld  【%s】     【错误的单词】---【0x100】\n",lineCount, lineWords, str);  
    }  
}  
/*******************从扫描缓冲区解析获取单词******************** 
state说明： 
0表示初始，10表示只含有字母，20表示含有数字，30表示含有$或_，40表示含有其他， 50表示读取完一个单词 
41表示字符串，42表示字符 
****************************************************************/  
void getWords(int state)  
{  
    char word[100];  
    int charCount = 0;  
    int finish = 0;  
    int i, j, k;    
    for(i = 0; scanBuf[i] != '\0'; i++)  
    {  
        switch(state/10)  
        {  
            case 0:  
                switch(getCharKind(scanBuf[i]))  
                {  
                    case 1:  
                        word[charCount++] = scanBuf[i];  
                        state = 10;  
                        break;  
                    case 2:  
                        word[charCount++] = scanBuf[i];  
                        state = 20;  
                        break;  
                    case 3:  
                        word[charCount++] = scanBuf[i];  
                        state = 30;  
                        break;  
                    case 0:  
                        word[charCount++] = scanBuf[i];  
                        switch(scanBuf[i])  
                        {  
                            case '"':  
                                state = 41;  
                                break;  
                            case '\'':  
                                state = 42;  
                                break;  
                            case '(': case ')': case '{': case '}': case '[': case ']': case ';': case ',': case '.':  
                                state = 50;  
                                word[charCount] = '\0';  
                                finish = 1;  
                                break;  
                            case '=':  
                                state = 43;  
                                break;  
                            default:  
                                state = 40;  
                                break;  
                        }  
                        break;  
                    default: word[charCount++] = scanBuf[i]; break;  
                }  
                break;  
            case 1:  
                switch(getCharKind(scanBuf[i]))  
                {  
                    case 1:  
                        word[charCount++] = scanBuf[i];  
                        state = 10;  
                        break;  
                    case 2:  
                        word[charCount++] = scanBuf[i];  
                        state = 20;  
                        break;  
                    case 3:  
                        word[charCount++] = scanBuf[i];  
                        state = 30;  
                        break;  
                    case 0:  
                        word[charCount] = '\0';  
                        i--;  
                        finish = 1;  
                        state = 50;  
                        break;  
                    default: word[charCount++] = scanBuf[i];break;  
                }  
                break;  
            case 2:  
                switch(getCharKind(scanBuf[i]))  
                {  
                    case 1:  
                        word[charCount++] = scanBuf[i];  
                        state = 20;  
                        break;  
                    case 2:  
                        word[charCount++] = scanBuf[i];  
                        state = 20;  
                        break;  
                    case 3:  
                        word[charCount++] = scanBuf[i];  
                        state = 30;  
                        break;  
                    case 0:  
                        if(scanBuf[i] == '.')  
                        {  
                            word[charCount++] = scanBuf[i];  
                            state = 20;  
                            break;  
                        }  
                        word[charCount] = '\0';  
                        i--;  
                        finish = 1;  
                        state = 50;  
                        break;  
                    default: word[charCount++] = scanBuf[i];break;  
                }  
                break;  
            case 3:  
                switch(getCharKind(scanBuf[i]))  
                {  
                    case 1:  
                        word[charCount++] = scanBuf[i];  
                        state = 30;  
                        break;  
                    case 2:  
                        word[charCount++] = scanBuf[i];  
                        state = 30;  
                        break;  
                    case 3:  
                        word[charCount++] = scanBuf[i];  
                        state = 30;  
                        break;  
                    case 0:  
                        word[charCount] = '\0';  
                        i--;  
                        finish = 1;  
                        state = 50;  
                        break;  
                    default: word[charCount++] = scanBuf[i];break;  
                }  
                break;  
            case 4:  
                switch(state)  
                {  
                    case 40:  
                        switch(getCharKind(scanBuf[i]))  
                        {  
                            case 1:  
                                word[charCount] = '\0';  
                                i--;  
                                finish = 1;  
                                state = 50;  
                                break;  
                            case 2:  
                                word[charCount] = '\0';  
                                i--;  
                                finish = 1;  
                                state = 50;  
                                break;  
                            case 3:  
                                word[charCount] = '\0';  
                                i--;  
                                finish = 1;  
                                state = 50;  
                                break;  
                            case 0:  
                                word[charCount++] = scanBuf[i];  
                                state = 40;  
                                break;  
                            default: word[charCount++] = scanBuf[i];break;  
                        }  
                        break;  
                    case 41:  
                        word[charCount++] = scanBuf[i];  
                        if(scanBuf[i] == '"')  
                        {  
                            if(getCharKind(scanBuf[i-1]) == 4)  
                            {  
                            }  
                            else  
                            {  
                                word[charCount] = '\0';  
                                finish = 1;  
                                state = 50;  
                            }  
                        }  
                        break;  
                    case 42:  
                        word[charCount++] = scanBuf[i];  
                        if(scanBuf[i] == '\'')  
                        {  
                            word[charCount] = '\0';  
                            finish = 1;  
                            state = 50;  
                        }  
                        break;  
                    case 43:  
                        if(scanBuf[i] == '=')  
                        {  
                            word[charCount++] = scanBuf[i];  
                            state = 43;  
                        }  
                        else  
                        {  
                            word[charCount] = '\0';  
                            finish = 1;  
                            i--;  
                            state = 50;  
                        }  
                        break;  
                    default: word[charCount++] = scanBuf[i];break;  
                }  
                break;  
            case 5:  
                finish = 0;  
                state = 0;  
                charCount = 0;  
                i--;  
                lineWords++;  
                totalWords++;  
                getWordKind(word);  
                break;  
            default:break;  
        }  
        if(scanBuf[i+1] == '\0')  
        {  
            word[charCount] = '\0';  
            lineWords++;  
            totalWords++;  
            getWordKind(word);  
        }  
    }  
}
biglxl
关注
词法分析器 c 语言
Just do it
11-19 1140
#include /*定义I/O库所用的某些宏和变量*/ #include /*定义字符串库函数*/ #include /*提供有关屏幕窗口操作函数*/ #include /*分类函数*/ #include char prog[80]={'\0'}, tok
词法分析器（c语言实现）
03-18
词法分析器源代码（C语言和c++语言）为编译原理课程设计课题，实现了一个功能简单能够对C文件进行分析的词法分析器
C语言词法分析器（简易）
11-23
简易C语言词法分析器：处理m语言源程序，过滤掉无用符号，判断源程序中单词的合法性，分解出正确的单词，输出二元组。
C语言实现词法分析器
11-02
编译技术实验：C语言实现词法分析器（Java源程序）
词法分析器-C语言
qq_41386300的博客
10-22 1万+
#include&lt;stdio.h&gt; #include&lt;conio.h&gt; #include&lt;math.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; int i, row = 0, line = 0; char test[1000]; //test文件中的字符 int number[100]; //常...
词法分析器C语言编写（附实验报告）
04-17
在C语言中编写词法分析器，我们需要对C语言的语法特性有深入理解，例如知道哪些字符组合可以构成合法的标识符，哪些是关键字，哪些是运算符，以及如何处理数字、字符串等常量。此外，我们还需要了解正则表达式或者...
cifafenxiqi.rar_cifafenxiqi_词法分析器 c语言_词法分析器能识别关键字常量和
09-21
对于给定的"Cifafenxiqi.rar_cifafenxiqi_词法分析器 c语言_词法分析器能识别关键字常量和"这个项目，我们关注的是一个使用C语言实现的简单词法分析器，它能够识别并处理特定类型的关键字、常量和标识符。...
cifafenxiqi.rar_词法分析器 c语言
09-20
在这个“cifafenxiqi.rar_词法分析器 c语言”项目中，开发者用C语言实现了这样一个词法分析器，旨在处理简单的源代码输入。 C语言是一种广泛使用的编程语言，因其高效、简洁而被许多系统级和嵌入式开发所采用。对于...
IORO.rar_编译原理 词法_词法分析器_词法分析器 c语言
09-22
《IORO.rar——深入理解编译原理：词法分析器的C语言实现》 在编程领域，编译器是至关重要的工具，它将人类可读的高级语言转换为机器可执行的指令。编译原理是计算机科学的一个核心分支，它研究如何构建这样的转换...
cifa.rar_yufa.c_词法分析器_词法分析器 c语言
09-21
在C语言环境中，编写词法分析器通常涉及对C源代码字符流的处理，识别关键字、标识符、常量、运算符等元素。 “cifa.rar_yufa.c”这个标题暗示我们有一个名为“yufa.c”的源代码文件，它可能是一个用C语言实现的词法...
c 语言 词法分析器
06-03
c 语言 词法分析器 编译原理 用c语言编写的一个词法分析器 词法分析器是学习编译原理的重要部分
C语言词法分析器
06-17
编译原理课程设计，用C语言实现C语言子集的词法分析器
c语言词法分析器
04-10
C编写的简易词法分析器，主要功能是：当你从文件输入一段c语言代码之后，程序能分析代码结构，解析代码的各种关键字，自定义标识符，数字等。
C语言实现简易C语言词法分析器
11-01
程序说明： 1、不考虑自定义头文件，#include < 规定这样开头，尖括号前面只能空一格。 2、标识符长度< 100,否则越界。 3、字符(串)常量，长度不可超过1， 但需要结尾。 4、注释会整行打印空行。 5、错误文件输出到error.txt；常量符号表：conTable.txt；变量符号表：varTable.txt；无头文件和注释的程序out.txt；token输出到token.txt 6、错误处理包括：不合法的浮点数，注释不封闭，转义字符不存在，头文件包含错误，程序中有非法字符。 7、为了显示注释不封闭的错误处理，定义超过10个字符的“/*”没有结尾就算不封闭。可以在global.h中进行更改，缓冲区大小，文件名长度，token, conTable, varTable的数组长度都可定义。由于struct中不是指针，比较占用空间，故不可分析太大的程序，容易数组越界。
词法分析器 c语言
06-18
一个用C语言编写的词法分析器，功能很全，与课本同步
基于C语言的词法分析器
最新发布
不懂编程的菜鸟
04-28 468
设计基于C语言的词法分析器。
深入浅出编译原理-4-一个简单词法分析器的C语言实现
duoerbasilu
07-06 1843
引言 光说不练，假把式。 此小节来做一个实验，用c语言自己实现一个简单的词法分析器，来加深对词法分析的理解。感兴趣的就自己分析一下源码吧，挺简单的，就没画流程图，请见谅。闲言少叙，我们开始吧。 4.1实验描述 例如：对源程序： begin x:=9: if x&gt;9 then x:=2*x+1/3; end # 的源文件，经过词法分析后输出如下序列： &lt;1,begin...
词法分析器（分析C语言）
热门推荐
flamingobaby的博客
10-10 4万+
问题描述：用C或C++语言编写一个简单的词法分析程序，扫描C语言小子集的源程序，根据给定的词法规则，识别单词，填写相应的表。如果产生词法错误，则显示错误信息、位置，并试图从错误中恢复。简单的恢复方法是忽略该字符（或单词）重新开始扫描。 相关词法规则 <标识符>::=<字母> <标识符>::=<标识符><字母> <标识符>::=<标识符><数字> <常量>::＝<无符号整数> <无符号整
电子科技大学词法分析器c语言
06-06
电子科技大学词法分析器c语言是一种基于C语言编写的词法分析器。它可以用来分析程序代码中的各种词法元素，例如关键字、标识符、常量、运算符等等。这个词法分析器采用了一些先进的自动机算法和正则表达式匹配算法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值