简单的词法分析程序

最新推荐文章于 2024-05-08 08:26:47 发布
最新推荐文章于 2024-05-08 08:26:47 发布
阅读量788 收藏 1
点赞数
分类专栏： 数据结构与算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaoxueyi551/article/details/9532389
版权

//入口类

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;

import org.omg.CORBA.portable.InputStream;


public class TestTokenAnanlize {

 public static void main(String[] args) throws IOException
 {
   MyCompiler cp = new MyCompiler();
   //接受读取的字符串
   String bufferOne = null;
   String bufferTwo = null;
   String scannerResult = null;
   StringBuffer fileString = new StringBuffer(50000);
   int Index = 0;
   int vitalIndex = 0;
   int helpVitalIndex = 0;
  
  
  
  //ArrayList的读 快改慢的特点适合作为关键字的比较
  ArrayList<String> str = new ArrayList<String>();
  
  File getFile = new File("abc.txt");
  File vitaleFile = new File("vital.txt");
  File targetFile = new File("targetfile.txt");
  
  //建立一个预定缓冲区的输入流，读取文件
  BufferedReader inOne = null;
  BufferedReader inTwo = null;
  BufferedWriter bf = null;
  
  //创建输入输出流，关联文件
  
 try{
   inTwo = new BufferedReader(new FileReader(vitaleFile));
   bf = new BufferedWriter(new FileWriter("targetfile.txt"),3000);
   inOne = new BufferedReader(new FileReader(getFile));
  
  
  //经测试，关键字被成功加入到str中
  while((bufferTwo = inTwo.readLine()) != null)
  {
   bufferTwo = bufferTwo.trim();
   
   while(vitalIndex < (bufferTwo.length()- 1))
   {
    if(bufferTwo.length() <= 0)
     break;
    while(bufferTwo.charAt(vitalIndex) != ',' && (vitalIndex < (bufferTwo.length()- 1)))
    {
     vitalIndex++;
    }
   
    str.add(bufferTwo.substring(helpVitalIndex, vitalIndex));
    System.out.println(str.get(str.size() - 1));
    
    helpVitalIndex = vitalIndex;
    vitalIndex++;
    helpVitalIndex++;
   }
   
   vitalIndex = 0;
   helpVitalIndex = 0;
  }
  
  
  //解析程序
  while((bufferOne = inOne.readLine()) != null)
  {
   
   //除去开头和结尾的空白
   bufferOne = bufferOne.trim();
   
   //不断调用Scanner()函数扫描每一行代码
   while(Index <= bufferOne.length() - 1 && bufferOne.length() != 0)
   {
    //出现异常
    scannerResult = cp.Scanner(bufferOne,Index,str);
    //如果是注释行，则推出循环
    if(scannerResult == "annotation")
    {
     break;
    }
    
    //将解析出来的单词存放在StringBuffer字符串缓冲区当中,留待以后写入文件
    fileString = fileString.append(new Character(scannerResult.charAt(0)).toString()
      + "  " + scannerResult.substring(1, scannerResult.length()) + "\n");
    
    //打印解析出来的单词
    System.out.println("(" + scannerResult.charAt(0) + "  " + 
      scannerResult.substring(1, scannerResult.length()) + ")");
    Index = cp.GetsecIndex();
    
    //观察100毫秒
    Thread.sleep(100);
   }
   
   //观察500毫秒
   Thread.sleep(500);
   
   //索引归位
   Index = 0;
  }
 
  
 }catch(IOException e){
  
  e.printStackTrace();
  
 } catch (InterruptedException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 }finally{
  
  inTwo.close();
  inOne.close();
  bf.close();
 }
 
  
 } 
}

 

//实现类

import java.util.ArrayList;

class MyCompiler {

 StringBuffer scannerResult = new StringBuffer(100);
 char ch;
 int signal = 0;
 int Index = 0;
 int secIndex = 0;
 boolean isKeyword = false;

 public MyCompiler() {
 }

 // 驱动表，抽象为一个字符数组，索引0~25为小写英文字母，26~51为大写英文字母，52~61为数字，
 // 62~74为界符，75~86为算符,87~93为特殊字符

 char[] c = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'f', 'k', 'l',
   'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
   'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
   'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
   'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '%',
   '&', '|', '<', '=', '>', '/', '+', '?', '!', '-', '[', ']', '{',
   '}', ',', ';', ':', '.', '"', '(', ')', '\\', '#', '@', '^', '~',
   '`', '$' };

 // 70 + 13 + 9 = 92
 // 62~73为算符
 // 86~91为特殊字符
 // secIndex变化，Index必须同步变化

 public String Scanner(String bufferOne, int Index, ArrayList<String> str) {
  // 主程序和被调程序的索引一致性检查
  if (secIndex == Index) {
   this.secIndex = Index;
   this.Index = Index;
  } else {
   this.secIndex = Index;
   this.Index = Index;
  }
  // 如果到达了一行的末尾,则说明已经开始解析下一行代码
  if (secIndex == bufferOne.length()) {
   // 索引归位
   secIndex = 0;
   this.Index = 0;
  }

  // 开始解析单词
  while ((bufferOne != null) && (secIndex <= bufferOne.length() - 1)) {
   // 进入扫描阶段，获取第一个字符，或者当前指针指向的字符
   ch = bufferOne.charAt(secIndex);

   // 如果是注释行，直接打印出来
   if (String.valueOf(ch).equals("/")
     && String.valueOf(bufferOne.charAt(secIndex + 1)).equals(
       "/")) {
    System.out.println(bufferOne);
    // if(secIndex <= bufferOne.length() - 1)
    // {
    secIndex = bufferOne.length();
    return "annotation";
    // }
    // else
    // {
    // secIndex = bufferOne.length();
    // return "//";
    // }
   }

   // 如果是数字常数
   if ((secIndex + 1) <= bufferOne.length() - 2
     && (Character.isDigit(ch) || (ch == '.' && Character
       .isDigit(bufferOne.charAt(secIndex + 1))))) {
    signal = 0;
   }
   // 如果是小写字母或者大写字母或者是下划线
   else if (Character.isLowerCase(ch) || Character.isUpperCase(ch)
     || ch == '_') {
    signal = 1;
   }

   // 如果是空白字符
   else if (Character.isSpaceChar(ch)) {
    signal = 3;
    secIndex = secIndex + 1;
    this.Index = secIndex;
   }
   // 其他情况为界符或者算符或者特殊字符
   else {
    for (int i = 62; i <= 73; i++) {
     if (ch == c[i]) {
      // 如果是算符
      signal = 4;
      break;
     }
    }
    // 如果不是算符,则判断是界符还是特殊字符
    if (signal != 4) {
     for (int i = 86; i <= 91; i++) {
      // 特殊字符
      if (ch == c[i]) {
       signal = 6;
       break;
      }
     }
     // 界符
     if (signal != 6) {
      signal = 5;
     }
    }
   }

   // 根据字符继续向后扫描，判断并返回指定字符串
   switch (signal) {
   case 0:

    // 循环的过程当中判断是否到达了一行的末尾
    while (Character.isDigit((bufferOne.charAt(secIndex)))) {
     if (secIndex < bufferOne.length() - 1) {
      secIndex++;
     } else {
      // 如果到达一行的末尾，将secIndex自增1，便于主程序操控，进入下一行的扫描
      secIndex = secIndex + 1;
      break;
     }
    }

    // 如果上面的while循环判断除了已经到达一行末尾，对出最外层while循环
    if (secIndex == bufferOne.length()) {
     scannerResult = new StringBuffer(bufferOne.substring(Index,
       secIndex));
     // 到达末尾，归零处理
     secIndex = 0;
     this.Index = 0;

     break;
    }

    // 若未到达末尾，判断当前字符是否为空格，如果为空格，则此锁定的字符串只可能是数字
    if (bufferOne.charAt(secIndex) == ' ') {
     // 将空格一起返回到main()方法,空间开销可能会比较大
     scannerResult = new StringBuffer(bufferOne.substring(Index,
       secIndex));
     this.Index = secIndex;

     // 追加常数标志位
     scannerResult = scannerResult.insert(0, '0');
    }

    // 2013年4月24日
    // 5.4e223,5.24E9,.78,3E535,543e4
    // 暂时不考虑正数中含有E字符的数字
    // 根据不同情况讨论

    else if ((bufferOne.charAt(secIndex) == '.')) {
     int figure = 0;
     while (Character.isDigit((bufferOne.charAt(secIndex
       + figure + 1)))) {
      if ((secIndex + figure + 1) == bufferOne.length() - 1) {
       secIndex = bufferOne.length();
       this.Index = bufferOne.length();
       return new StringBuffer(bufferOne.substring(Index,
         secIndex + figure + 1)).insert(0, '0')
         .toString();
      }
      figure++;
     }

     secIndex = secIndex + figure + 1;
     this.Index = secIndex + figure + 1;
     scannerResult = new StringBuffer(bufferOne.substring(Index,
       secIndex));

     scannerResult.insert(0, '0');

     /****
      * if(figure != 0 && (bufferOne.charAt(secIndex + figure) ==
      * 'E')) {
      * while(Character.isDigit((bufferOne.charAt(secIndex +
      * figure + 1)))) { figure++; } //此时secIndex +
      * figure处的字符已经非数字 //687678jio; scannerResult = new
      * StringBuffer(bufferOne.substring(Index,secIndex +
      * figure)); secIndex = secIndex + figure; this.Index =
      * secIndex;
      *
      * //追加常数标志位，并且是一个小数，并且包含E scannerResult =
      * scannerResult.insert(0, '0');
      *
      * }
      *
      * //数字中不包含E的情况 else if(figure != 0 &&
      * (bufferOne.charAt(secIndex + figure) != 'E')) {
      * scannerResult = new
      * StringBuffer(bufferOne.substring(Index,secIndex +
      * figure)); secIndex = secIndex + figure; this.Index =
      * secIndex;
      *
      * //追加常数标志位，并且是一个小数，并且不包含E scannerResult =
      * scannerResult.insert(0, '0'); }
      *******/

    }

    // 直接截取数字
    else {
     scannerResult = new StringBuffer(bufferOne.substring(Index,
       secIndex));
     this.Index = secIndex;

     // 设为标示符
     scannerResult = scannerResult.insert(0, '0');

    }
    break;

   //case 1:
   case 1:

    //System.out.println("enter in 111111111");
    // 需要判断是否为关键字
    while (Character.isLowerCase((bufferOne.charAt(secIndex)))
      || Character.isUpperCase(((bufferOne.charAt(secIndex))))
      || bufferOne.charAt(secIndex) == '_'
      || Character.isDigit(bufferOne.charAt(secIndex))) {
     if (secIndex < bufferOne.length() - 1) {
      secIndex++;
     } else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      // scannerResult = scannerResult.insert(0, '2');
      secIndex = bufferOne.length();
      this.Index = bufferOne.length();

      // return scannerResult.toString();
      break;
     }
    }

    /****
     * //判断是否为保留字
     * if(Character.isLowerCase((bufferOne.charAt(secIndex)))) {
     * //判断是否为保留字曾经出现异常
     * if(this.isKeyword(str,bufferOne.substring(Index,secIndex +
     * 1))) { scannerResult = new
     * StringBuffer(bufferOne.substring(Index,secIndex + 1));
     * scannerResult.insert(0, '2'); this.Index = secIndex; break; }
     * } else { isKeyword = false; } }
     *****/
    /**
     * //出现保留字,跳出循环，将保留字返回给主控程序 if(isKeyword == true) { break; }
     *
     * //循环结束后没有遇到保留字 出现异常 scannerResult = new
     * StringBuffer(bufferOne.substring(Index,secIndex)); this.Index
     * = secIndex;
     ******/
    
    //到达该行末尾说明已经截取了单词
    if (secIndex == bufferOne.length()) {

    }
    //如果没有到达该行的末尾
    else {
     scannerResult = new StringBuffer(bufferOne.substring(Index,
       secIndex));
     this.Index = secIndex;
    }

    if (isKeyword(str, scannerResult.toString())) {
     // 是保留字
     scannerResult = scannerResult.insert(0, '7');
    } else {
     // 不是保留字,则是关键字
     scannerResult = scannerResult.insert(0, '2');
    }
    
    //secIndex++;
    this.Index = secIndex;
    break;

   case 3:
    while (bufferOne.charAt(secIndex) == ' ') {
     secIndex++;
    }
    
    this.Index = secIndex;
    break;
    
    
   // 判断算符
   case 4:

    // 判断是否为“==”
    if (ch == '=') {
     // kjkjkjn==
     if (((secIndex + 1) <= bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     } else if ((secIndex + 1) == bufferOne.length()) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     }
    }

    else if (ch == '+') {
     if (((secIndex + 1) <= bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     } else if (((secIndex + 1) < bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '+') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     } else if (((secIndex + 1) < bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) != '='
       && bufferOne.charAt(secIndex + 1) != '+') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '-') {
     if (((secIndex + 1) <= bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '-') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     } else if (((secIndex + 1) < bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     } else if (((secIndex + 1) < bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) != '-'
       && bufferOne.charAt(secIndex + 1) != '=') {
      if (Character.isDigit(bufferOne.charAt(secIndex + 1))) {
       // 为减号或者负号
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 1));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 1;
       this.Index = secIndex;
      }

     }
    }

    else if (ch == '*') {
     if (((secIndex + 1) <= bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) == bufferOne.length()) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '/') {
     if (((secIndex + 1) <= (bufferOne.length() - 1) && bufferOne
       .charAt(secIndex + 1) == '=')) {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) == bufferOne.length()) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();

     } else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '%') {
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) == bufferOne.length()) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '!') {
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) == bufferOne.length()) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '&') {
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '&') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) == bufferOne.length()) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     }
    }

    else if (ch == '|') {
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) == (bufferOne.length())) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '|') {
      secIndex = secIndex + 2;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) != '|') {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     }
     /*****
      * else { scannerResult = new
      * StringBuffer(bufferOne.substring(Index,secIndex + 1));
      * scannerResult = scannerResult.insert(0, 4); secIndex =
      * secIndex + 1; this.Index = secIndex; }
      *****/
    }

    else if (ch == '>') {
     // >=
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     // >>=,>>>
     else if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '>') {
      if ((secIndex + 2) <= (bufferOne.length() - 1)
        && bufferOne.charAt(secIndex + 2) == '=') {
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 3));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 3;
       this.Index = secIndex;
      }

      else if ((secIndex + 2) <= (bufferOne.length() - 1)
        && bufferOne.charAt(secIndex + 2) == '>') {
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 3));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 3;
       this.Index = secIndex;
      } else if ((secIndex + 2) <= (bufferOne.length() - 1)
        && bufferOne.charAt(secIndex + 2) != '>'
        && bufferOne.charAt(secIndex + 2) == '=') {
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 2));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 2;
       this.Index = secIndex;
      } else if ((secIndex + 2) == (bufferOne.length())) {
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 2));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 2;
       this.Index = secIndex;
      }

      else {
       // 这种情况按照无符号位移处理
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 2));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 2;
       this.Index = secIndex;
      }
     }

     /****
      * else if(bufferOne.charAt(secIndex + 1) == '>' &&
      * bufferOne.charAt(secIndex + 2) == '>') { scannerResult =
      * new StringBuffer(bufferOne.substring(Index,++secIndex));
      * scannerResult = scannerResult.insert(0, 4); this.Index =
      * secIndex; }
      ****/

     // 纯'>'号
     else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '<') {
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     }

     else if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '<') {
      if ((secIndex + 2) <= (bufferOne.length() - 1)
        && bufferOne.charAt(secIndex + 2) == '=') {
       scannerResult = new StringBuffer(
         bufferOne.substring(Index, secIndex + 3));
       scannerResult = scannerResult.insert(0, '4');
       secIndex = secIndex + 3;
       this.Index = secIndex;
      }

/***
        else if(bufferOne.charAt(secIndex + 1) == '<')
        {
         scannerResult = new StringBuffer(bufferOne.substring(Index,secIndex + 2));
         scannerResult = scannerResult.insert(0, 4);
         secIndex = secIndex + 2;
         this.Index = secIndex;
        }
        ***/

      else if ((secIndex + 2) == (bufferOne.length())) {
       secIndex = secIndex + 2;
       this.Index = secIndex;
       return new StringBuffer(bufferOne.substring(Index,
         secIndex)).insert(0, '4').toString();
      }
     }

     // 纯'<'号
     else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    else if (ch == '^') {
     if ((secIndex + 1) <= (bufferOne.length() - 1)
       && bufferOne.charAt(secIndex + 1) == '=') {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 2));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 2;
      this.Index = secIndex;
     } else if ((secIndex + 1) == (bufferOne.length())) {
      secIndex = secIndex + 1;
      this.Index = secIndex;
      return new StringBuffer(bufferOne.substring(Index,
        secIndex)).insert(0, '4').toString();
     } else {
      scannerResult = new StringBuffer(bufferOne.substring(
        Index, secIndex + 1));
      scannerResult = scannerResult.insert(0, '4');
      secIndex = secIndex + 1;
      this.Index = secIndex;
     }
    }

    break;

   case 5:

    // 如果当前字符是'"'
    if (ch == '"') {
     while (bufferOne.charAt(secIndex) != '"') {
      secIndex++;
     }
     scannerResult = new StringBuffer(bufferOne.substring(this.Index,this.secIndex + 1));
     scannerResult = scannerResult.insert(0, '8');
     this.Index = secIndex;
     
    }else
    {
     scannerResult = new StringBuffer(new Character(ch).toString());
     scannerResult = scannerResult.insert(0, '5');
    }

    secIndex++;
    this.Index = secIndex;
    break;
   case 6:
    scannerResult = new StringBuffer(new Character(ch).toString());
    scannerResult = scannerResult.insert(0, '6');

    secIndex = secIndex + 1;
    this.Index = secIndex;
    break;

   }// switch结束

   break;

  }// while 结束

  return scannerResult.toString();

 }// scanner结束

 private boolean isKeyword(ArrayList<String> str, String s) {
  int i;
  boolean isTrue = false;

  for (i = 0; i <= str.size() - 1; i++) {
   // 注意此处必须使用“equals()方法”，不能使用“==”
   if (s.equals(str.get(i))) {
    isTrue = true;
    break;
   }
  }

  return isTrue;
 }

 public int GetsecIndex() {
  return secIndex;
 }

}

// 一、算术运算符：

// 单目：：+（取正）-（取负） ++（自增1） - -（自减1）
// 双目：+ - * / %（取余）
// 三目：a>b?true:false

// 二、关系运算：

// 等于符号:==，不等于符号: != ，大于符号:>， 小于符号:<，大于等于符号: >= ，小于等于符号: <=

// 三、位运算符 逻辑运算符：

// 位运算符　与（&）、非（~）、或（|）、异或（^）
// 逻辑运算符 与（&&）、非（!）、或（||）

// 四、赋值运算符

// = += -= *= /= %= &= ^= |= <<= >>=

// 七 位移运算符

// << 带符号左移 >>带符号右移 >>> 无号右移

 

 

 

 

Paul-LangJun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言词法分析程序实验报告,实验一词法分析程序设计与实现
weixin_33443932的博客
05-17 3160
实验一词法分析程序设计与实现一、实验目的：加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。二、实验内容：自定义一种程序设计语言，或者选择已有的一种高级语言(C语言)，编制它的词法分析程序。词法分析程序的实现可以采用任何一种编程工具。三、实验要求：1. 对单词的构词规则有明确的定义；2. ...
使用c语言编写词法分析程序,用C语言编写一个简单的词法分析程序
weixin_35231615的博客
05-19 7808
问题描述：用C或C++语言编写一个简单的词法分析程序，扫描C语言小子集的源程序，根据给定的词法规则，识别单词，填写相应的表。如果产生词法错误，则显示错误信息、位置，并试图从错误中恢复。简单的恢复方法是忽略该字符(或单词)重新开始扫描。相关词法规则::=::=::=::＝::=::=::=::=a|b|c|……|x|y|z::=0|1|2|3|4|5|6|7|8|9::＝+|-::=*|／::＝|!...
【编译原理】简单词法分析程序的实现C语言
qq_51639901的博客
03-27 1万+
编译原理课程的实验二：编制简单词法分析程序。 实验内容：通过了解词法分析程序的功能，设计词法分析程序，通过逐个字符的扫描和分解，能够识别出一个一个单词以及单词的分类；删除注释并进行词法检查，报告所发现的错误（比如标识符不能以数字开头，123aaa就不是合法的标识符），建立符号表。 实验说明：单词通常分为五种类型： （1）基本字：（关键字，保留字）如if else int break等 （2）运算符：如+ - * / = ...
编译原理（1）简单词法分析程序（C++实现）
CH_whale的博客
11-21 1493
（1）判断由科学计数法表示的整数的正则表达式不完整，存在缺漏。（2）以逗号分割单句表达式，当char或string语句中存在逗号时，会出错。改进思路：当逗号存在于char或string中时，进行优先级判断。
C语言实现简单 词法分析程序（编译原理）
pythonstrat的博客
11-26 1万+
要求 代码书写（详细注释，亲自修改，测试无误） #include <stdio.h> #include <string.h> char prog[80],token[8]; char ch, en='a'; int syn,p,m,n,sum; char *rwtab[6]={"begin","if","then","while","do","end"}; void main() { void scaner(); p=0; // 不以# 结尾，程序将一直等待输入：查看get
制作一个简单的C语言词法分析程序
JJ-Li的博客
10-27 2186
基于文法构建字符表，制作对应程序做词法分析
编译原理——词法分析程序
最新发布
m0_74219898的博客
05-08 1684
分程序>→[<常量说明部分>][<变量说明部分>][<过程说明部分>]<复合语句><语句>→<赋值语句>|<条件语句>|<当型循环语句>|<过程调用语句><过程说明部分>→<过程首部><分程序>；{<过程首部><分程序>；<常量说明部分>→CONST<常量定义>{，<常量定义>}；<条件>→<表达式><关系运算符><表达式> | ODD<表达式><写语句>→WRITE(<表达式>{，<表达式>})<表达式>→[+|-]<项>{<加型运算符><项>}<当型循环语句>→WHILE<条件>DO<语句>
编译原理实验1———简单词法分析程序
m0_62616221的博客
12-12 1054
简单词法分析程序
c语言词法分析程序实验报告,词法分析器实验报告
weixin_32171133的博客
05-17 2251
词法分析器实验报告词法分析器设计一、二、 实验目的：对C语言的一个子集设计并实现一个简单的词法分析器，掌握利用状态转换图设计词法分析器的基本方法。利用该词法分析器完成对源程序字符串的词法分析。输出形式是源程序的单词符号二元式的代码，并保存到文件中。二、实验内容：1. 设计原理词法分析的任务：从左至右逐个字符地对源程序进行扫描，产生一个个单词符号。理论基础：有限自动机、正规文法、正规式词法分析器(L...
编译原理词法分析程序c语言实现,编译原理之词法分析程序
weixin_33277564的博客
05-18 1211
实验课上实现了对词法分析程序的编写。整个过程中，最为困难的就是对整个编译过程的设计。在这里整理一下我的整个从设计到实现过程以及中间出现的问题。问题描述假定一种高级程序设计语言中的单词主要包括关键字begin、end、for、if、then、else；标识符；整数；六种关系运算符，试构造能识别这些单词的词法分析程序。下面是各类单词符号以及编码对应表最后我们将实现输入一段代码，然后输出键值对的形式：输...
快速排序的稳定性分析
热门推荐
gaoxueyi551的专栏
04-20 2万+
快速排序是一个不稳定的排序算法，本文将着重分析该算法不稳定的原因所在。 首先，考虑下图中对一个关键字都为 1 的序列所进行的交换操作。 如图，交换前，枢纽元已放置在最后一个位置。图中，当遇到和枢纽元大小相同的元素时，游标 选择继续前进，直到与游标 相遇为止，然后将枢纽元与游标 和 所指向的元素交换，再递归的对左右两边的数...
关于矩阵乘法运算顺序上的技巧
gaoxueyi551的专栏
04-12 6874
如果存在A, B, C三个矩阵，其中 B 为方阵，且 C 的列数较 A 的行数少时，则计算 A(BC) 比(AB)C 更省算力。 分析： 若假定HOR(A) = 100，COL(C) = 50，HOR(B) = COL(B) = N, 则 A(BC) 的计算量为： HOR(A) * COL(BC) +...
理解均摊时间复杂度
gaoxueyi551的专栏
12-26 4004
均摊时间复杂度分析，又叫摊还分析（或者叫平摊分析）。均摊时间复杂度，听起来跟平均时间复杂度有点儿像。对于初学者来说，这两个概念确实非常容易弄混。大部分情况下，我们并不需要区分最好、最坏、平均三种复杂度。平均复杂度只在某些特殊情况下才会用到，而均摊时间复杂度应用的场景比它更加特殊、更加有限。我还是借助一个具体的例子来理解。 // array表示一个长度为n的数组 // 代码中...
基于快速排序的O（N）时间复杂度的TopK算法原理
gaoxueyi551的专栏
04-19 3936
一、背景 实际应用中，我们经常面临这样的问题，即从一个序列S中选择其中最大的K个数（一般情况下K远小于|S|），我们将这种问题称为TopK问题。 举一个例子，美剧《权利的游戏》中的每个人物，观众都会对其进行选择支持或不支持，这样每个人物都会都应一个热度值，这个值可以是支持者的数量，我们可以发现在腾讯视频中该剧中热度排名前3的人物加以了高亮标识，如下图： ...
Python实现两个有序集合的交集和并集
gaoxueyi551的专栏
01-11 2946
本文通过python实现简易的集合交并算法，输入是两个以递增顺序排序的集合，输出它们的有序交集和有序并集。 1、Union算法 def union(s1, s2): o = [] i = j = 0 s1_n = len(s1) s2_n = len(s2) while i < s1_n and j < s2_n: ...
python速率控制器
gaoxueyi551的专栏
11-20 2192
最近有空和同事共同开发了一个基于python的速率控制器，可以控制数据的处理速度，在很多场景中相信都会用到，故在此分享给大家。 一、代码 主要思想：控制一段时间内处理数据的速度，速度不能超过设定的speed值。例如，speed值设定为100，那就是说每秒数据处理的速度上限是100. #coding=utf-8 import time import datetime from time import sleep class SpeedControl(object): def _...
大数存储
gaoxueyi551的专栏
09-20 2114
/** 挑战类型表示的极限 解决思路: 用一个数组存储一个大数，每个数组元素存储大数中的一位数字，然后采用逐位相乘，后位向前进位的方法计算大数的阶乘值 只要数组长度定义的足够大，就可以计算足够大的数的阶乘值。 */ #include #include #define SIZE 51 int main(){ int data[SIZE] = {0}; /* 存储50位数，元素全部
O(n*lgn)时间复杂度的逆序对统计算法实现思想
gaoxueyi551的专栏
03-28 1887
逆序对定义：设A[1..n]是一个包含n个不同数的数组。如果在i A[j],则(i,j)就称为A中的一个逆序对(inversion)。 现给出一个算法，其可以用O(n*lgn)的最坏情况运行时间，确定n个元素的任何排列中逆序对的数量。 简单的算法实现思想：我们可以单纯的通过从前往后的逐一比对来确定逆序对的数量，虽然实现简单，但这样一来时间复杂度将会上升为O(n*n),不符合我们的要求。
对误差反向传播的理解和学习
gaoxueyi551的专栏
02-22 1743
关于反向传播，我非常推荐下面的一个在线书籍，其给出了非常详实、生动且易于理解的反向传播算法以及相关公式的推导，链接为：Neural Networks and Deep Learning。本文将对其讲解给以归纳和总结，其中不乏添加一些个人见解。 本文将使用如下图所示神经网络进行推导。 一、符号假设 损失函数为 第 层的第 个神经元的偏置为，输入层没有偏置 第...
C语言词法分析程序设计
完成实验后，学生应提交包含实验过程、遇到的问题、解决方案以及结果的实验报告，同时需要在计算机上运行并调试成功自己的词法分析程序，以证明其功能正确性和效率。这样的实践有助于学生深入理解编程语言的底层机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值