词法分析时单词的识别依据什么来实现

词法分析时单词的识别根据构词规则识别单词。

1、词法分析的任务

词法分析是编译的第一个阶段，其任务是：从左至右逐个字符地对源程序（用高级语言编写的）进行扫描，产生一个个单词符号，把字符串形式的源程序改造成为单词符号串形式的中间程序。

2、词法分析器

执行词法分析的程序称为词法分析程序，也称为词法分析器或扫描器。词法分析器的功能是输入源程序，输出单词符号。

3、词法分析的两种处理结构

（1）把词法分析程序作为主程序。即，把词法分析与语法分析明显分开，由词法分析程序将字符串形式的源程序改造成单词符号串形式的中间程序，以这个中间程序作为语法分析程序的输入。在这种处理结构中，词法分析和语法分析实际上是分别实现的。

（2）把词法分析程序作为语法分析程序调用的子程序。在进行语法分析时，每当语法分析程序需要一个单词时，便调用词法分析程序，词法分析程序每一次调用便从字符串源程序中识别出一个单词交给语法分析程序。词法分析和语法分析实际上是交替进行的。

任务1：识别小型语言所有单词的词法分析程序设计

源程序设计语言 G[<程序>]

<程序>→<变量说明><BEGIN><语句表><END>.

<变量说明>→VAR<变量表>:<类型>；|<空>

<变量表>→<变量表>,<变量>|<变量>

<类型>→INTEGER

<语句表>→<语句>| <语句><语句表>

<语句>→<赋值语句>|<条件语句>|<WHILE语句>|<复合语句>

<赋值语句>→<变量>:=<算术表达式>

<条件语句>→IF<关系表达式>THEN<语句>ELSE<语句>

<WHILE语句>→WHILE<关系表达式>DO<语句>

<复合语句>→BEGIN<语句表>END

<算术表达式>→<项>|<算术表达式>+<项>|<算术表达式>-<项>

<项>→<因式>|<项>*<因式>|<项>/<因式>

<因式>→<变量>|<整数>|(<算术表达式>)

<关系表达式>→<算术表达式><关系符><算术表达式>

<变量>→<标识符>

<标识符>→<标识符><字母>|<标识符><数字>|<字母>

<整数>→0|<非零数字><泛整数>

<泛整数>→<数字>|<数字><泛整数>|ε

<关系符>→<|<=|==|>|>=|<>

<字母>

→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

<非零数字>→1|2|3|4|5|6|7|8|9

<数字>→<非零数字>|0

<空>→

要求和提示：

词法分析阶段，可以打开任意位置和名称的源文件进行词法分析，可以进行非法字符和数字后边跟字母的错误判断，如果没有错误则提示“词法分析正确完成！”，并且可以选择输出token.txt（token文件）string.txt（符号表）两个文件；

1．词法分析程序的主要任务如下：

① 组织源程序的输入，识别出源程序中的各个基本语法单位（也称为单词或语法符号），按规则转换成二元式的形式；

② 删除无用的空白字符、回车符、及其它非实质性符号；

③ 删除注解行；

④ 为后面的语法和语义分析提供二元式链表；

单词 编码 单词 编码

标识符 1 <15

正整数 2 <= 16

BEGIN 3 >17

END 4 >= 18

IF 5 <>19

THEN 6 == 20

ELSE 7 ； 21

WHILE 8 ． 22

DO 9 := 23

INTEGER 10 ， 24

+ 11 ( 25

- 12 ） 26

* 13

/ 14

1) 对标识符的长度控制在8个字符（包括8个）以内，超过的做截断处理；

2) 数字不大于65535，否则报错；

3) 能跳过源程序中的空白格：两个单词之间的任何空格，制表符，回车，换行都是白空格，除了用来分隔单词以外，没有意义；

4) 能跳过注释：

a) 接连出现的/*到下一次接连出现的*/之间的任何文字都是注释（多行）；

b) 从某行接连出现的//到该行的结尾的任何文字都是注释（单行）。

3.怎样编写词法分析程序：

1） 预处理：把源文件一个字符一个字符的读入词法分析程序设置的输入字符结构体数组中（输入缓冲区），读入过程要删除注释，删除多余的白空格；

2） 从源程序字符数组中获得单词, 编码为二元式.：

二元式采用结构体数组存储, 把单词类型和词元记录下来。

分解单词的方法：

1） Case多路转换语句根据单词的特点直接编写；

2） 通过描述单词的正规文法得到相应的有穷自动机，通过case多路转换语句完成有穷自动机的处理流程。

3．编写词法分析程序要注意的问题：

1） 检查词法是否有错误

检查是否有非法字符：如 @, &, !

检查标志符和数字是否满足限制条件

检查注释符号是否配对

2） 符分隔单词

能够区分两个单词的符号为界符

有些界符不是单词：如白空格

有些界符仅仅用来分隔：如；

有些界符本身还是源程序不可缺少的单词，如(, ), +, /, 等等

有些界符包含两个字符：如<>, >=等等

3） 输出词法错误

如果有错误，需要报告词法错误的原因。并且要能够越过错误，分解下一个单词，直到源程序结束。

4） 输出的二元式流保存在二元式结构体数组中。

你好，希望采纳！

首先看下我们要分析的代码段如下：

输出结果如下：

输出结果(a).PNG

输出结果(b).PNG

输出结果(c).PNG

括号里是一个二元式：（单词类别编码，单词位置编号）

代码如下：

?

1234567891011121314package Yue.LexicalAnalyzer import java.io.* /* * 主程序 */public class Main {  public static void main(String[] args) throws IOException {    Lexer lexer = new Lexer()    lexer.printToken()    lexer.printSymbolsTable()  }}

?

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283package Yue.LexicalAnalyzer import java.io.*import java.util.* /* * 词法分析并输出 */public class Lexer {  /*记录行号*/  public static int line = 1  /*存放最新读入的字符*/  char character = ' '   /*保留字*/  Hashtable<String, KeyWord>keywords = new Hashtable<String, KeyWord>()  /*token序列*/  private ArrayList<Token>tokens = new ArrayList<Token>()  /*符号表*/  private ArrayList<Symbol>symtable = new ArrayList<Symbol>()   /*读取文件变量*/  BufferedReader reader = null  /*保存当前是否读取到了文件的结尾*/  private Boolean isEnd = false   /* 是否读取到文件的结尾 */  public Boolean getReaderState() {    return this.isEnd  }   /*打印tokens序列*/  public void printToken() throws IOException {    FileWriter writer = new FileWriter("E:\\lex.txt")    System.out.println("词法分析结果如下：")    System.out.print("杜悦-2015220201031\r\n\n")    writer.write("杜悦-2015220201031\r\n\r\n")    while (getReaderState() == false) {      Token tok = scan()      String str = "line " + tok.line + "\t(" + tok.tag + "," + tok.pos + ")\t\t"          + tok.name + ": " + tok.toString() + "\r\n"      writer.write(str)      System.out.print(str)    }    writer.flush()   }   /*打印符号表*/  public void printSymbolsTable() throws IOException {    FileWriter writer = new FileWriter("E:\\symtab1.txt")    System.out.print("\r\n\r\n符号表\r\n")    System.out.print("编号\t行号\t名称\r\n")    writer.write("符号表\r\n")    writer.write("编号 " + "\t行号 " + "\t名称 \r\n")    Iterator<Symbol>e = symtable.iterator()    while (e.hasNext()) {      Symbol symbol = e.next()      String desc = symbol.pos + "\t" + symbol.line + "\t" + symbol.toString()      System.out.print(desc + "\r\n")      writer.write(desc + "\r\n")    }     writer.flush()  }   /*打印错误*/  public void printError(Token tok) throws IOException{    FileWriter writer = new FileWriter("E:\\error.txt")    System.out.print("\r\n\r\n错误词法如下：\r\n")    writer.write("错误词法如下：\r\n")    String str = "line " + tok.line + "\t(" + tok.tag + "," + tok.pos + ")\t\t"        + tok.name + ": " + tok.toString() + "\r\n"    writer.write(str)  }   /*添加保留字*/  void reserve(KeyWord w) {    keywords.put(w.lexme, w)  }   public Lexer() {    /*初始化读取文件变量*/    try {      reader = new BufferedReader(new FileReader("E:\\输入.txt"))    } catch (IOException e) {      System.out.print(e)    }     /*添加保留字*/    this.reserve(KeyWord.begin)    this.reserve(KeyWord.end)    this.reserve(KeyWord.integer)    this.reserve(KeyWord.function)    this.reserve(KeyWord.read)    this.reserve(KeyWord.write)    this.reserve(KeyWord.aIf)    this.reserve(KeyWord.aThen)    this.reserve(KeyWord.aElse)  }   /*按字符读*/  public void readch() throws IOException {    character = (char) reader.read()    if ((int) character == 0xffff) {      this.isEnd = true    }  }   /*判断是否匹配*/  public Boolean readch(char ch) throws IOException {    readch()    if (this.character != ch) {      return false    }     this.character = ' '    return true  }   /*数字的识别*/  public Boolean isDigit() throws IOException {    if (Character.isDigit(character)) {      int value = 0      while (Character.isDigit(character)) {        value = 10 * value + Character.digit(character, 10)        readch()      }       Num n = new Num(value)      n.line = line      tokens.add(n)      return true    } else      return false  }   /*保留字、标识符的识别*/  public Boolean isLetter() throws IOException {    if (Character.isLetter(character)) {      StringBuffer sb = new StringBuffer()       /*首先得到整个的一个分割*/      while (Character.isLetterOrDigit(character)) {        sb.append(character)        readch()      }       /*判断是保留字还是标识符*/      String s = sb.toString()      KeyWord w = keywords.get(s)       /*如果是保留字的话，w不应该是空的*/      if (w != null) {        w.line = line        tokens.add(w)      } else {        /*否则就是标识符，此处多出记录标识符编号的语句*/        Symbol sy = new Symbol(s)        Symbol mark = sy      //用于标记已存在标识符        Boolean isRepeat = false        sy.line = line        for (Symbol i : symtable) {          if (sy.toString().equals(i.toString())) {            mark = i            isRepeat = true          }        }        if (!isRepeat) {          sy.pos = symtable.size() + 1          symtable.add(sy)        } else if (isRepeat) {          sy.pos = mark.pos        }        tokens.add(sy)      }      return true    } else      return false  }   /*符号的识别*/  public Boolean isSign() throws IOException {    switch (character) {      case '#':        readch()        AllEnd.allEnd.line = line        tokens.add(AllEnd.allEnd)        return true      case '\r':        if (readch('\n')) {          readch()          LineEnd.lineEnd.line = line          tokens.add(LineEnd.lineEnd)          line++          return true        }      case '(':        readch()        Delimiter.lpar.line = line        tokens.add(Delimiter.lpar)        return true      case ')':        readch()        Delimiter.rpar.line = line        tokens.add(Delimiter.rpar)        return true      case '':        readch()        Delimiter.sem.line = line        tokens.add(Delimiter.sem)        return true      case '+':        readch()        CalcWord.add.line = line        tokens.add(CalcWord.add)        return true      case '-':        readch()        CalcWord.sub.line = line        tokens.add(CalcWord.sub)        return true      case '*':        readch()        CalcWord.mul.line = line        tokens.add(CalcWord.mul)        return true      case '/':        readch()        CalcWord.div.line = line        tokens.add(CalcWord.div)        return true      case ':':        if (readch('=')) {          readch()          CalcWord.assign.line = line          tokens.add(CalcWord.assign)          return true        }        break      case '>':        if (readch('=')) {          readch()          CalcWord.ge.line = line          tokens.add(CalcWord.ge)          return true        }        break      case '<':        if (readch('=')) {          readch()          CalcWord.le.line = line          tokens.add(CalcWord.le)          return true        }        break      case '!':        if (readch('=')) {          readch()          CalcWord.ne.line = line          tokens.add(CalcWord.ne)          return true        }        break    }    return false  }    /*下面开始分割关键字，标识符等信息*/  public Token scan() throws IOException {    Token tok    while (character == ' ')      readch()    if (isDigit() || isSign() || isLetter()) {      tok = tokens.get(tokens.size() - 1)    } else {      tok = new Token(character)      printError(tok)    }    return tok  }}

---