codeformatterfactory.cs

C#更新版的C语言的词法分析器

using System;
using System.IO;
using System.Text;
using System.Windows.Forms;
using System.Collections;

namespace CodeFormatter {
  /// <summary>
  /// CodeFormatterFactory 的摘要说明。
  /// c 代码解析,不支持中文
  /// </summary>
  public class CodeFormatterFactory {
    /*源代码*/
    private string sourceCode = "";

    /*C语言所有关键字，共32个*/
    ArrayList KeyWordList = new ArrayList();

    /*运算、限界符*/
    ArrayList LimitList = new ArrayList();

    /*常量表*/
    ArrayList ConstList = new ArrayList();

    /*标识符*/
    ArrayList IdentifierList = new ArrayList();

    /*输出*/
    ArrayList OutputList = new ArrayList();

    public CodeFormatterFactory() {
      //
      // TODO: 在此处添加构造函数逻辑
      //
      init();
    }

    public string SourceCode{
      get{return this.sourceCode;}
      set{this.sourceCode =value;}
    }

    public string ParseMessages{
      get{
        string pm = "";

        IEnumerator ie = this.OutputList.GetEnumerator();
        while ( ie.MoveNext() )
          pm += ie.Current.ToString() + "\r\n";
        return pm;
      }
    }

    private void init() {
      /*C语言所有关键字，共32个*/
      string[] key=new string[]{" ","auto","break","case","char","const","continue","default","do","double",
                                 "else","enum","extern","float","for","goto","if","int","long","register",
                                 "return","short","signed","sizeof","static","struct","switch","typedef",
                                 "union","unsigned","void","volatile","while"};
      /*运算、限界符*/
      string[] limit=new string[]{" ","(",")","[","]","->",".","!","++","--","&","~",
                                   "*","/","%","+","-","<<",">>","<","<=",">",">=","==","!=","&&","||",
                                   "=","+=","-=","*=","/=",",",";","{","}","#","_","'"};

      this.KeyWordList.Clear();
      this.KeyWordList.TrimToSize();
      for(int i=1;i<key.Length;i++)
        this.KeyWordList.Add(key[i]);

      this.LimitList.Clear();
      this.LimitList.TrimToSize();
      for(int i=1;i<limit.Length;i++)
        this.LimitList.Add(limit[i]);

      this.ConstList.Clear();
      this.ConstList.TrimToSize();

      this.IdentifierList.Clear();
      this.IdentifierList.TrimToSize();

      this.OutputList.Clear();
      this.OutputList.TrimToSize();
    }

    /*******************************************
    * 十进制转二进制函数
    *******************************************/
    private string dtb(string buf){
      int[] temp= new int[20];
      string binary = "";
      int val=0,i=0;

      /*先将字符转化为十进制数*/
      try{
        val = Convert.ToInt32(buf);
      }catch{
        val = 0;
      }

      if(val==0) {
        return(val.ToString());
      }

      i=0;
      while(val!=0) {
        temp[i++]=val%2;
        val/=2;
      }

      binary = "";
      for(int j=0;j<=i-1;j++)
        binary += (char)(temp[i-j-1]+48);

      return(binary);
    }

    /*******************************************
    * 根据不同命令查表或造表函数
    *******************************************/
    private int find(string buf,int type,int command){     
      int number=0;
      string temp;

      IEnumerator ie = null;
      ArrayList al = null;
      switch(type){
        case 1://关键字表
          ie = this.KeyWordList.GetEnumerator();
          break;
        case 2://标识符表
          ie = this.IdentifierList.GetEnumerator();
          break;
        case 3://常数表
          ie = this.ConstList.GetEnumerator();
          break;
        case 4://运算、限界符表
          ie = this.LimitList.GetEnumerator();
          break;
      }            

      if(ie!=null)
      while (ie.MoveNext()){
        temp = ie.Current.ToString();
        if(temp.Trim().ToLower()==buf.Trim().ToLower()){
          return number;
        }
        number ++;
      }
      
      if(command==1){
        /*找不到，当只需查表，返回0，否则还需造表*/
        return 0;
      }

      switch(type){
        case 1: al = this.KeyWordList;break;
        case 2: al = this.IdentifierList;break;
        case 3: al = this.ConstList;break;
        case 4: al = this.LimitList;break;
      }
      if(al!=null)
        al.Add(buf);

      return number + 1;
    }
    /*******************************************
    * 数字串处理函数
    *******************************************/
    private void cs_manage(string buffer){
      string binary = dtb(buffer);
      int result = find(binary,3,2);
      this.OutputList.Add(String.Format("{0}\t\t\t3\t\t\t{1}",buffer,result));
    }

    /*******************************************
    * 字符串处理函数 
    *******************************************/
    private void ch_manage(string buffer) {
      int result = find(buffer,1,1);
      if(result!=0){
        this.OutputList.Add(String.Format("{0}\t\t\t1\t\t\t{1}",buffer,result));
      }else{
        result = find(buffer,2,2);
        this.OutputList.Add(String.Format("{0}\t\t\t2\t\t\t{1}",buffer,result));
      }
    }

    /*******************************************
    * 出错处理函数
    *******************************************/
    private void er_manage(char error,int lineno) {
      this.OutputList.Add(String.Format("错误关键字: {0} ，所在行: {1}",error,lineno));
    }

    /*******************************************
    * 转换Char数组为string
    ******************************************/
    private string joinString(char[] array,int Length){
      string s = "";
      if(array.Length>0)
        for(int i=0;i<Length;i++){
          if(array[i]!='\0') {
            s+=array[i];
          }else{
            break;
          }
        }
      return s;
    }

    private char getchc(ref int n){
      char[] c = sourceCode.ToCharArray();
      if(n<c.Length){
        char r = c[n];      
        n++;
        return r;
      }
      return sourceCode[sourceCode.Length-1];
    }
    /*******************************************
    * 扫描程序
    ********************************************/
    public void Parse() {
      //StreamWriter fpout = null;
      char ch ;
      int i=0,line=1;
      int count,result,errorno=0;
      char[] array = new char[30];
      string word= "";

      /*按字符依次扫描源程序，直至结束*/
      int n = 0;

      while(n<sourceCode.Length-1){
        i = 0;
        ch = getchc(ref n);
        /*以字母开头*/
        if(((ch>='A')&&(ch<='Z'))||((ch>='a')&&(ch<='z'))||(ch=='_')) {		            
          while(((ch>='A')&&(ch<='Z'))||((ch>='a')&&(ch<='z'))||(ch=='_')||((ch>='0')&&(ch<='9'))) {
            array[i++]=ch;
            ch = getchc(ref n);
          }
          array[i++] = '\0';
          word = joinString(array,array.Length);
          ch_manage(word);
          if(n<sourceCode.Length)n--;
        }else if(ch>='0'&&ch<='9') {
          /*以数字开头*/
          while(ch>='0'&&ch<='9') {
            array[i++]=ch;
            ch = getchc(ref n);
          }
          array[i++] = '\0';
          word=joinString(array,array.Length);
          cs_manage(word);
          if(n<sourceCode.Length)n--;
        }
        else if((ch==' ')||(ch=='\t'))
          /*消除空格符和水平制表符*/
          ;
        else if(ch=='\n')
          /*消除回车并记录行数*/
          line++;
        else if(ch=='/') {
          /*消除注释*/		                  
          ch = getchc(ref n);
          if(ch=='=') {
            /*判断是否为‘/=’符号*/
            this.OutputList.Add(String.Format("/=\t\t\t4\t\t\t32"));
          }
          else if(ch!='*') {
            /*若为除号，写入输出*/
            this.OutputList.Add(String.Format("/\t\t\t4\t\t\t13"));
            n--;
          } else if(ch=='*') {
            /*若为注释的开始，消除包含在里面的所有字符*/
            count=0;
            ch = getchc(ref n);
            while(count!=2) {
              /*当扫描到‘*’且紧接着下一个字符为‘/’才是注释的结束*/
              count=0;
              while(ch!='*')
                ch = getchc(ref n);
              count++;
              ch = getchc(ref n);
              if(ch=='/')
                count++;
              else
                ch = getchc(ref n);
            }
          }
        }
        else if(ch=='"') {
          /*消除包含在双引号中的字符串常量*/
          this.OutputList.Add(String.Format("{0}\t\t\t4\t\t\t37",ch));
          while(ch!='"')
            ch = getchc(ref n);
          this.OutputList.Add(String.Format("{0}\t\t\t4\t\t\t37",ch));
        }
        else {
          /*首字符为其它字符,即运算限界符或非法字符*/
          array[0]=ch;
          /*再读入下一个字符，判断是否为双字符运算、限界符*/
          ch = getchc(ref n);
          /*若该字符非结束符*/
          if(n<sourceCode.Length) {
            array[1]=ch;
            array[2] = '\0';
            word = joinString(array,2);
            result=find(word,4,1); /*先检索是否为双字符运算、限界符*/
            if(result==0) {
              /*若不是*/	
              array[2] = '\0';
              word = joinString(array,1);
              result=find(word,4,1);      
              /*检索是否为单字符运算、限界符*/
              if(result==0) {
                /*若还不是，则为非法字符*/
                er_manage(array[0],line);
                errorno++;
                n--;
              }
              else {
                /*若为单字符运算、限界符，写入输出并将扫描指针回退一个字符*/
                this.OutputList.Add(String.Format("{0}\t\t\t4\t\t\t{1}\t",word,result));
                n--;
              }
            }
            else {
              /*若为双字符运算、限界符，写输出*/
              this.OutputList.Add(String.Format("{0}\t\t\t4\t\t\t{1}",word,result));
            }
          }
          else {
            /*若读入的下一个字符为结束符*/
            array[2] = '\0';
            word = joinString(array,1);
            /*只考虑是否为单字符运算、限界符*/
            result=find(word,4,1);
            /*若不是，转出错处理*/
            if(result==0)
              er_manage(array[0],line);
            else {
              /*若是，写输出*/
              this.OutputList.Add(String.Format("{0}\t\t\t4\t\t\t{1}",word,result));
            }
          }
        }
        ch = getchc(ref n);
      }
      /*报告错误字符个数*/
      this.OutputList.Add(String.Format("\n共有 {0} 个错误.\n",errorno));
    }

  }
}