一. 介紹

詞法分析器，又稱掃描器，輸入源程式，進行詞法分析，輸出單詞符號。詞法分析僅僅是編譯程式工作中的一部分，編譯程式一般可以劃分為5個階段：詞法分析，語法分析，語義分析與中間程式碼產生，優化，目的碼生成。我們這裡編寫一個簡單的C語言源程式詞法分析器。

二. 目的

設計並實現一個包含預處理功能的詞法分析程式，加深對編譯中詞法分析過程的理解。

四. 要求

1、實現預處理功能

源程式中可能包含有對程式執行無意義的符號，要求將其剔除。
首先編制一個源程式的輸入過程，從鍵盤、檔案或文字框輸入若干行語句，依次存入輸入緩衝區（字元型資料）；然後編制一個預處理子程式，去掉輸入串中的回車符、換行符和跳格符等編輯性文字；把多個空白符合併為一個；去掉註釋。

2、實現詞法分析功能

輸入：所給文法的源程式字串。
輸出：二元組（syn,token或sum）構成的序列。其中，
syn為單詞種別碼。
Token為存放的單詞自身字串。
Sum為整型常量。
具體實現時，可以將單詞的二元組用結構進行處理。

3、待分析的C語言子集的詞法

1）關鍵字
main if then while do static int double struct break else long switch case typedef char return const float short continue for void default sizeof do
所有的關鍵字都是小寫。
2）運算子和界符
+ - * / : := < <> <= > >= = ; ( ) #
3）其他標記ID和NUM
通過以下正規式定義其他標記：
ID→letter(letter|digit)*
NUM→digit digit*
letter→a|…|z|A|…|Z
digit→0|…|9…
4）空格由空白、製表符和換行符組成
空格一般用來分隔ID、NUM、專用符號和關鍵字，詞法分析階段通常被忽略。

4、各種單詞符號對應的種別碼

單詞符號    種別碼        單詞符號    種別碼       
main        1            void       23     
if          2            sizeof     24     
then        3            ID         25  
while       4            NUM        26
do          5             +         27   
static      6             -         28
 
     
int         7             *         29  
double      8             /         30     
struct      9            **         31   
break       10           ==         32  
else        11           <          33   
long        12           <>         34  
switch      13           <=         35 
case        14           >          36
typedef     15           >=         37
char        16           =          38
return      17           [          39
const       18           ]          40 
float       19           ;          41 
short       20           (          42 
continue   21            )          43 
for         22           #          0  

五. 原始碼

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LexicalAnalyzer {

    static String[] rwtab=new String[]{"main","if","then","while","do","static",
                                "int","double","struct","break","else",
                                "long","switch","case","typedef","char",
                                "return","const","float","short","continue",
                                "for","void","sizeof"};   //已經定義的24個關鍵字，種別碼從1開始
    static String storage="";   //儲存源程式字串
    static StringBuilder token=new StringBuilder("");     //儲存單詞自身組成的字串

    static char ch;
    static int index;
    static int syn, sum=0, row;

     //分析器
    static void analyzer(){
        token.delete(0, token.length());                //置空token物件，清除
        ch=storage.charAt(index++);
        while(ch==' '){
            ch=storage.charAt(index++);      //去除空格符號
        }

        if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){         //可能是關鍵字或者自定義的識別符號
            while((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){
                token.append(ch);
                ch=storage.charAt(index++);
            }
            index--;      //此次識別的最後一個字元未識別入，需要將標記退原處 
            syn=25;       //預設為識別出的字串為自定義的識別符號，種別碼為25
            String s=token.toString();
            for(int i=0; i<rwtab.length; i++){
                if(s.equals(rwtab[i])){     
                    syn=i+1;
                    break;        //識別出是關鍵字
                }
            }
        }
        else if((ch>='0'&&ch<='9')){
            sum=0;
            while((ch>='0'&&ch<='9')){
                sum=sum*10+ch-'0';
                ch=storage.charAt(index++);
            }
            index--;
            syn=26;
        }
        else switch(ch){

        case '<':
            token.append(ch);
            ch=storage.charAt(index++);
            if(ch=='='){
                token.append(ch);
                syn=35;
            }
            else if(ch=='>'){
                token.append(ch);
                syn=34;
            }
            else{
                syn=33;
                index--;
            }
            break;
        case '>':
            token.append(ch);
            ch=storage.charAt(index++);
            if(ch=='='){
                token.append(ch);
                syn=37;
            }
            else{
                syn=36;
                index--;
            }
            break;
        case '*':
            token.append(ch);
            ch=storage.charAt(index++);
            if(ch=='*'){
                token.append(ch);
                syn=31;
            }
            else{
                syn=13;
                index--;
            }
            break;
        case '=':
            token.append(ch);
            ch=storage.charAt(index++);
            if(ch=='='){
                syn=32;
                token.append(ch);
            }
            else{
                syn=38;
                index--;
            }
            break;
        case '/':
            token.append(ch);
            ch=storage.charAt(index++);
            if(ch=='/'){
                while(ch!=' '){
                    ch=storage.charAt(index++);  //忽略掉註釋，以空格為界定
                }
                syn=-2;
                break;
            }
            else{
                syn=30;
                index--;
            }
            break;
        case '+':
            syn=27;
            token.append(ch);
            break;
        case '-':
            syn=28;
            token.append(ch);
            break;
        case ';':
            syn=41;
            token.append(ch);
            break;
        case '(':
            syn=42;
            token.append(ch);
            break;
        case ')':
            syn=43;
            token.append(ch);
            break;
        case '#':
            syn=0;
            token.append(ch);
            break;
        case '\n':
            syn=-2;
            token.append(ch);
            break;
        default:
            syn=-1;
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
        index=0;
        row=1;
        String tempString;
        System.out.println("請輸入C語言源程式字串（以#結尾）：");

        //輸入過程
        try{
            do{
                tempString=stdin.readLine();
                storage+=tempString;
                ch=tempString.charAt(tempString.length()-1);  //得到一行中最後一個字元
            }while(ch!='#');        //輸入以#字元結尾
        }catch(IOException e){
            e.printStackTrace();
        }

        index=0; 
        //輸出過程
        do{
            analyzer();
            switch(syn){
            case 26:
                System.out.println("("+syn+","+sum+")");
                break;
            case -1:
                System.out.println("Error in row"+row+"!");
                break;
            case -2:
                break;
            default:
                System.out.println("("+syn+","+token+")");
            }
        }while(syn!=0);
    }

}

六. 執行結果