2. 程式人生 > >實驗二 詞法分析器的實現

實驗二 詞法分析器的實現

阿新 • • 發佈：2019-02-02

這裡定義了一個程式語言稱作C－M i n u s (或簡稱為C－)，這是一種適合編譯器設計方案的
語言，它比T I N Y語言更復雜，包括函式和陣列。本質上它是C的一個子集，但省去了一些重要
的部分，因此得名。這個附錄由5小節組成。首先，我們列出了語言慣用的詞法，包括語言標
記的描述。其次，給出了每個語言構造的B N F描述，同時還有相關語義的英語描述。在A . 3節，
給出了C－的兩個示例程式。再者，描述了C－的一個Tiny Machine執行時環境。最後一節描述
了一些使用C－和T M的程式設計設計方案，適合於一個編譯器教程。

C－慣用的詞法

  1. 下面是語言的關鍵字：
 else
 
 if int return void while

所有的關鍵字都是保留字，並且必須是小寫。
2. 下面是專用符號：

+ - * / < <= > >= == != = ; , ( ) [ ] { } /* */
  1. 其他標記是I D和N U M，通過下列正則表示式定義：
ID = letter letter*
NUM = digit digit*
letter = a|..|z|A|..|Z
digit = 0|..|9

小寫和大寫字母是有區別的。
4. 空格由空白、換行符和製表符組成。空格通常被忽略，除了它必須分開I D、N U M關鍵字。
5. 註釋用通常的C語言符號/ * … * /圍起來。註釋可以放在任何空白出現的位置(即註釋不能放在標記內)上，且可以超過一行。註釋不能巢狀。

詞法分析器的DFA：

這裡寫圖片描述

原始碼實現：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<iostream>
#define intputfile "test.c"
#define outputfile "target.c"
typedef int sInt;
using namespace std;

FILE *source;
FILE *target;

long beginp[5];   //記錄檔案指標的開始位置
 

long endp[5];    //記錄檔案指標的結束位置
char idStr[80]="";   //儲存識別符號中間值
int state[5]={0}; //不同記號型別的狀態
char unaryOP[16]={'+','-','*','/','<','>','=',';',',','(',')','[',']','{','}','!'}; //儲存一元運算子
char *p[6]={"if","else","int","return","void","while"};  //系統保留字
char *strToken[7]={"ID","NUM","OP","FUCN","RESW","ERROR","COM"};
typedef enum {ID,NUM,OP,FUCN,RESW,ERROR,COM}tokenType; //記號型別

void clearState()
{
    memset(state,0,sizeof(state));
    memset(idStr,'\0',sizeof(idStr));
    memset(beginp,0,sizeof(beginp));
    memset(endp,0,sizeof(endp));
}

void strPrintf(long begin,long end,tokenType t)
{
    bool isComment = false;
    int k;
    char s[200]="";
    long len=end-begin;
    fseek(source,-len,1);//檔案指標回退
    for(int i=0;i<len;i++) s[i]=fgetc(source);
    switch(t)
    {
        case ID:
        k=0;break;
        case NUM:
        k=1;break;
        case OP:
        k=2;break;
        case FUCN:
        k=3;break;
        case RESW:
        k=4;break;
        case ERROR:
        k=5;break;
        case COM:
        k=6;
        isComment=true;break;
        default:cout<<"輸入有誤！\n";
    }
    //printf("%s\n",s);
    if(isComment)
    {
        fprintf(target,"%s\n",s);
        printf("%s\n",s);
    }

    else
    {
        fprintf(target,"<%s,%s>\n",strToken[k],s);
        printf("<%s,%s>\n",strToken[k],s);
    }
}

void unaryPrintf(char s,tokenType t)
{
    int k;
    switch(t)
    {
        case ID:
        k=0;break;
        case NUM:
        k=1;break;
        case OP:
        k=2;break;
        case FUCN:
        k=3;break;
        case RESW:
        k=4;break;
        case ERROR:
        k=5;break;
        case COM:
        k=6;break;
        default:cout<<"輸入有誤！\n";
    }
    //cout<<strToken[k]<<endl;
    fprintf(target,"<%s,%c>\n",strToken[k],s);
    printf("<%s,%c>\n",strToken[k],s);
}

bool isOperator(char ch)
{
    for(int i=0;i<16;i++)
    {
        if( ch==unaryOP[i] )
        return true;
    }
    return false;
}
void number(char ch,int i)
{
    beginp[i]=ftell(source)-1;
    while(!feof(source))
    {
        if(ch>='0' && ch<='9')
        {
            state[i]=1;
            endp[i]=ftell(source);
        }else
        {
            fseek(source,-1L,1); //回退,讀到了下一個字元
            strPrintf(beginp[i],endp[i],NUM);
            return;
        }
        ch = fgetc(source);
    }
}
void comment(char ch,int i)
{
    bool isexit = false; //當不是註釋時用於跳出迴圈
    while(!feof(source))
    {
        switch(state[i])
        {
            case 0:
            if(ch=='/')
            {
                state[i]=1;
                beginp[i]=ftell(source)-1;
            }
            break;
            case 1:
            if(ch=='*')
            {
                state[i]=2;
            }
            else
            {
                isexit = true; //說明不是註釋，請求退出
                unaryPrintf('/',OP);
                fseek(source,-1L,1); //回退一個位元組，因為向後判斷移了一位
            }
            break;
            case 2:
            if(ch=='*')
            {
                state[i]=3;
            }else
            {
                state[i]=2;
            }
            break;
            case 3:
            if(ch=='/')
            {
                state[i]=4;
                endp[i]= ftell(source);
                strPrintf( beginp[i],endp[i],COM);
                isexit = true;                               //back
            }else state[i]=2;
            break;
        }
        if(isexit) return;//back;
        ch = fgetc(source);
    }
}


void myOperator(char ch,int i)
{
    bool isReturn = false;
    while(!feof(source))
    {
        if(ch=='+' ||ch=='-'||ch=='*'||ch==';'||ch==','||ch=='('||ch==')'||ch=='['||ch==']'||ch=='{'||ch=='}')
        {
            state[i]=1;
            unaryPrintf(ch,OP);
            isReturn = true;
        }else
        {
            switch(state[i])
            {
                case 0:
                beginp[i]=ftell(source)-1;
                switch(ch)
                {
                    case '<':
                    state[i]=2;
                    break;
                    case '>':
                    state[i]=4;
                    break;
                    case '=':
                    state[i]=6;
                    break;
                    case '!':
                    state[i]=8;
                    break;
                    default:cout<<"data error!\n";
                }
                break;
                case 2:
                if(ch=='=')
                {
                    state[i]=3;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //屬於一元操作符
                    state[i]=2;
                    fseek(source,-1L,1);//回退一個字元
                    unaryPrintf('<',OP);
                    isReturn = true;
                }
                break;
                case 4:
                if(ch=='=')
                {
                    state[i]=5;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //屬於一元操作符
                    state[i]=4;
                    fseek(source,-1L,1);//回退一個字元
                    unaryPrintf('>',OP);
                    isReturn = true;
                }
                break;
                case 6:
                if(ch=='=')
                {
                    state[i]=7;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //屬於一元操作符
                    state[i]=6;
                    fseek(source,-1L,1);//回退一個字元
                    unaryPrintf('=',OP);
                    isReturn = true;
                }
                break;
                case 8:
                if(ch=='=')
                {
                    state[i]=9;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //屬於一元操作符
                    state[i]=8;
                    fseek(source,-1L,1);//回退一個字元
                    unaryPrintf('!',OP);
                    isReturn = true;
                }
                break;
                default:cout<<"data error!\n";
            }
        }
        if(isReturn) return;
        ch = fgetc(source);
    }
}
bool isLiter(char ch)
{
    if((ch>='A' && ch<='Z')||( ch>= 'a' && ch<='z') || ch=='_')
    {
        return true;
    }else
    return false;
}

bool isResw(char *s)
{
    for(int i=0;i<6;i++)
    {
        if( strcmp(s,p[i])==0 )
        return true;
    }
    return false;
}

void identifier(char ch,int i)
{
    beginp[i] = ftell(source)-1;
    long len =0;
    bool isQuit = false;
    bool isFucn = false;
    while(!feof(source))
    {
        if( isLiter(ch) )
        {
            state[i]=1;
            endp[i]=ftell(source);
        }
        else
        {
            long enter = 1; //
            isQuit = true;
            if(ch=='\n') enter = 2;
            fseek(source,-enter,1); //回退一或2個字元
            //cout<<"pos="<<ftell(source)<<endl;
            //printf("%d %d\n",beginp[i],endp[i]);
            len = endp[i]-beginp[i];
            fseek(source,-len,1);
            //cout<<"pos="<<ftell(source)<<endl;
            for(int j=0;j<len;j++)
            {
                idStr[j] = fgetc(source);

            }
            if( isResw(idStr) ) //如果是保留字，就儲存退出
            {
                strPrintf(beginp[i],endp[i],RESW);

            }else
            {
                char temps;
                long cout=1;
                temps = fgetc(source);
                while(!feof(source))
                {
                    if(temps==' ' ||temps=='\n' || temps=='\t')
                    {
                        ; //jump it;
                    }else
                    {
                        if(temps=='(')
                           {
                               isFucn = true; //表明是函式名
                               break;
                           }
                        else
                           {
                               isFucn = false; //不是函式名
                               break;
                           }
                    }
                    temps = fgetc(source);
                    cout++;
                }
                fseek(source,-cout,1); //回退檔案指標
                //printf("back=%ld\n",ftell(source));
                if(isFucn)
                {
                    strPrintf(beginp[i],endp[i],FUCN);
                }else
                {
                    strPrintf(beginp[i],endp[i],ID);
                }
            }
        }
        if(isQuit) return;
        ch = fgetc(source);
    }
}

void Scanner()
{
    char ch=fgetc(source);
    while( !feof(source) )
    {
        if(ch==' ' ||ch=='\n' || ch=='\t')
        {
            ;//nothing jump it!
        }else if(ch=='/')
        {
            comment(ch,0);
            clearState(); //清楚狀態資訊
        }else if(ch>='0'&&ch<='9')
        {
            number(ch,1); //處理數字
            clearState();
        }else if( isOperator(ch) )
        {
            myOperator(ch,2); //處理操作符
            clearState();
        }else if( isLiter(ch) )
        {
            identifier(ch,3); //處理標誌符
            clearState();
        }
        else
        {
            unaryPrintf(ch,ERROR);
        }
        ch = fgetc(source);
    }
}

bool read(){
   if(((source=fopen(intputfile,"r"))==NULL)||((target=fopen(outputfile,"w"))==NULL))
    return 0;
    return 1;
}
int main()
{
    if(!read()){
        printf("檔案開啟失敗!");
        exit(0);
    }
    Scanner();  //開始掃描檔案 entrance
    fclose(source);
    fclose(target);
    return 0;
}

輸入檔案：

int gcd (int u, int v)
{
    if (v == 0)
        return u ;
    else
        return gcd(v,u-u/v*v);
    /* u-u/v*v == u mod v */
}

void main(void)
{
    int x;int y;
    x = input();
    y = input();
    output(gcd(x,y));
}

輸出檔案：

<RESW,int>
<FUCN,gcd>
<OP,(>
<RESW,int>
<ID,u>
<OP,,>
<RESW,int>
<ID,v>
<OP,)>
<OP,{>
<RESW,if>
<OP,(>
<ID,v>
<OP,==>
<NUM,0>
<OP,)>
<RESW,return>
<ID,u>
<OP,;>
<RESW,else>
<RESW,return>
<FUCN,gcd>
<OP,(>
<ID,v>
<OP,,>
<ID,u>
<OP,->
<ID,u>
<OP,/>
<ID,v>
<OP,*>
<ID,v>
<OP,)>
<OP,;>
/* u-u/v*v == u mod v */
<OP,}>
<RESW,void>
<FUCN,main>
<OP,(>
<RESW,void>
<OP,)>
<OP,{>
<RESW,int>
<ID,x>
<OP,;>
<RESW,int>
<ID,y>
<OP,;>
<ID,x>
<OP,=>
<FUCN,input>
<OP,(>
<OP,)>
<OP,;>
<ID,y>
<OP,=>
<FUCN,input>
<OP,(>
<OP,)>
<OP,;>
<FUCN,output>
<OP,(>
<FUCN,gcd>
<OP,(>
<ID,x>
<OP,,>
<ID,y>
<OP,)>
<OP,)>
<OP,;>
<OP,}>

相關推薦

實驗二 詞法分析器的實現

這裡定義了一個程式語言稱作C－M i n u s (或簡稱為C－)，這是一種適合編譯器設計方案的 語言，它比T I N Y語言更復雜，包括函式和陣列。本質上它是C的一個子集，但省去了一些重要 的部分，因此得名。這個附錄由5小節組成。首先，我們列出了語言慣用的

JAVA實驗二：編碼實現一個類對輸入陣列的數從小到大排序同時使用二分法查詢某一個數（遞迴和非遞迴）

編碼實現一個類 （1）提供一個靜態方法，可以將輸入的一個int[]陣列按照從小到大的順序排列； （2）提供靜態方法，對排好序的陣列使用折半（二分）查詢（使用遞迴和非遞迴兩種形式分別實現）查詢某一個整數。 答案 import java.util.*; public class

C# 詞法分析器（二）輸入緩沖和代碼定位

自己 ML 轉換 .html 優點 有時 表示 error hub 系列導航 （一）詞法分析介紹 （二）輸入緩沖和代碼定位 （三）正則表達式 （四）構造 NFA （五）轉換 DFA （六）構造詞法分析器 （七）總結 一、輸入緩沖 在介紹如何進行

在三層交換機上實現DHCP中繼實驗二

默認路由 shadow interface com serve inter pro 自動獲取 dhcp服務 要求：三層交換機連接兩個部門設計部和市場部，分別處於vlan10和vlan20中，vlan10的網關地址為192.168.10.1/24，vlan20的網關地址為1

編譯原理實驗二：LL(1)語法分析器

處理 字符 編號 析構 idt public 輸入 課本 字母 一、實驗要求 　　 　　不得不想吐槽一下編譯原理的實驗代碼量實在是太大了，是編譯原理撐起了我大學四年的代碼量... 　　這次實驗比上次要復雜得多，涵蓋的功能也更多了，我覺得這次實驗主要的難點有兩個（其實都是難點

編譯原理實驗 —— 詞法分析器

// Lexical_Analysis.cpp : 定義控制檯應用程式的入口點。 // #include "stdio.h" #include "stdlib.h" #include "string.h" #include "iostream" using namespace std; //詞法分析程式

實驗二：棧與佇列的實現與應用

1、順序棧： #include <iostream> using namespace std; const int StackSize=10; class SeqStack{ public: SeqStack(); //建構函式，初始化一個空棧 ~SeqStack(){

資料結構實驗6：C++實現二叉樹類

實驗6 學號：     姓名：      專業：   6.1 實驗目的 掌握二叉樹的動態連結串列儲存結構及表示。 掌握二叉樹的三種遍歷演算法（遞迴和非遞迴兩類）。 運用二叉樹三種遍歷的方法求解有關問題。 6

編譯原理-詞法分析器1(lex實現)

編譯原理課實驗一是詞法分析器，但是在網上查了很多資料，發現用lex實現還要用Linux，Windows可以用對應的flex實現，但是網上的資料很零散，所以整理了一下從安裝到配置，到實現一個詞法分析器的過程 一、 安裝 開啟安裝好的軟體，選Basic

作業系統- 實驗二 模擬處理機排程的SJF排程演算法（Java實現）

                                          &

二、詞法分析器構造原理

一、正則式（regular expression） 1.正則式定義： ε表示語言{ε}，a表示語言{a}，(r)|(s)表示語言L(r)並L(s)，(r)(s)表示語言L(r)L(s)，(r)*表示語言(L(r))* 正則式優先順序為 閉包>連線>或，即((

一個簡單詞法分析器的C語言實現

1.1實驗描述 例如：對源程式： begin x:=9: if x>9 then x:=2*x+1/3; end # 的原始檔，經過詞法分析後輸出如下序列： <1,begin><10,x><18,:=><11,9><26,;><

（編譯原理）java實現詞法分析器

1、閒話 最近在學編譯原理，需要用語言實現一個詞法分析器，其實挺簡單的，主要涉及一些語言字串操作處理，如果會正則表示式的話，感覺實現這個會很簡單，但是我並不會啊，然後自己用java實現了，也算是加強了對java的一些字元操作方法的使用。 實現這個分析器，演算法上基本上沒什麼難度，

數字影象實驗二：幾何變換與變形c++實現

實驗2.1：影象縮放 實現一個影象縮放函式，可以對輸入影象進行任意倍數的縮放； 採用雙線性插值進行重取樣； X,Y方向的縮放倍數參函式引數的形式傳入； 可以只考慮輸入影象為3通道，8位深度的情況； 不能呼叫影象處理庫的縮放函式來完成； 實驗2.2：影

JS詞法分析器實驗報告

1.實驗環境 Linux系統  WebStorm環境 2.實驗目的 設計、編制、除錯一個詞法分析子程式－識別單詞，加深對詞法分析原理的理解 3.單詞分類表 4.單詞狀態表 5.演算法描述 用Javascipt實現詞法分析器，首先是讀取檔案，然後把讀入的字元轉為陣列

JAVA實驗二：設計一個教師類Teacher（屬於cn.net.sdkd包）實現介面進行排序等

設計一個教師類Teacher（屬於cn.net.sdkd包） （1）屬性有編號（int no）、姓名（String name）、年齡（int age）、所屬學院（String seminary），為這些屬性設定相應的get和set方法。 （2）為Teacher類重寫equals方

JAVA實驗二：使用一維陣列編碼實現一個棧（Stack）類

題目：使用一維陣列編碼實現一個棧（Stack）類，要求提供以下操作 （1）boolean isEmpty()：判斷棧當前是否為空； （2）入棧操作void push(obj)：把資料元素obj插入堆疊； （3）出棧操作Object pop()：出棧，並返回刪除的資料元素；（4）Obj

JAVA實驗二：利用二維陣列（double[]）實現一個矩陣類：Matrix的相乘、轉置、相加等

題目：利用二維陣列（double[]）實現一個矩陣類：Matrix。 要求提供以下方法： （1）set（int row, int col, double value）：將第row行第col列的元素賦值為value； （2）get（int row，int col）：取第row行第c

實驗二：順序表的實現

一、實驗目的 建立一個由n個學生成績的順序表，n的大小由自己確定，每一個學生的成績資訊由自己確定，實現資料的對錶進行插入、刪除、查詢等操作。分別輸出結果。 二、實驗過程 #ifndef SeqList_H #define SeqList_H const int Maxsi

簡單詞法分析器的實現

這是我們的一次程式設計作業，要求用C編寫一個簡單的詞法分析器。要求如下： 編制一個單詞獲取程式，從檔案輸入的源程式中，識別出各個具有獨立意義的單詞，即關鍵字、識別符號、整數、小數、字串、分隔符、運算子等七大類。並依次輸出各個單詞的內部編碼及單詞符號自身文字串（遇到錯誤時可顯示