展开全部

Lex是美国Bell实验室用C语言研制的一个词法分析程序自生成工具62616964757a686964616fe78988e69d8331333361303131

。它的基本原理就是使用正则表达式扫描匹配文本，并为每一个匹配模式定义一些操作，当用C语言作宿主语言时，这些操作都由C语言实现。

一种匹配的正则表达式可能会包含相关的动作。这一动作可能还包括返回一个标记。当 Lex 接收到文件或文本形式的输入时，它试图将文本与正则表达式进行匹配。它一次读入一个输入字符，直到找到一个匹配的模式。如果能够找到一个匹配的模式，Lex 就执行相关的动作(可能包括返回一个标记)。另一方面，如果没有可以匹配的正则表达式，将会停止进一步的处理，Lex 将显示一个错误消息。

Lex 和 C 是强耦合的。一个 .l 文件(Lex 文件具有 .l 的扩展名)通过 lex 公用程序来传递，并生成 C 的输出文件。这些文件被编译为词法分析器的可执行版本。

本程序对java源程序进行分析，主要实现以下两个功能：

(1)、清除注释。java源程序有三种注释方法：1、单行注释，以//开头直到行结束；2、多行注释，以/*为开始，*/为结束，可以注释多行；3、java文档注释，这也是一种多行注释，但它可以通过java文档生成工具写入java程序文档中。它以/**为开始，*/为结束。

(2)、通过程序行数计算工作量。

(3)、计算程序中类的个数，并判断有没有两个public类，如果存在则报错：There is an error:One java file cannot includes two public class。

单行注释的清除。由于单行注释以//开头直到行结束，首先要匹配的就是//，然后清除从匹配处到行结束的所有字符。具体实现如下：

"//" {

int c;

while ( (c = input()) != '/n' &&

c != EOF )

{

;

}

code = add(code,'/n');

}

多行注释的清除。多行注释有两种，一种是普通多行注释，另一种是java文档注释。这两种注释都以*/结束，普通多行注释以/*开始，java文档注释以/**开始。可以先匹配/*，然后向后搜索*/。要区别这两种注释就要看/*后面是否紧跟一个*字符，如果不是则为普通多行注释；如果是还要看下一字符是否为/字符，如果是也为普通注释，如果不是则为java文档注释。具体lex程序实现如下：

"/*" {

int c,ct=0;

char * javadoc = "/*there is a Java Doc Comment*/";

for ( ; ; )

{

while ( (c = input()) != '*' &&

c != EOF )

{

ct++;

}

if ( c == '*' )

{

c = input();

if ( c == '/' )

{

ct = 0;

break; /* found the end */

}

else

{

if(ct==0)

code = strcat(code,javadoc);

}

}

if ( c == EOF )

{

printf( "EOF in comment" );

break;

}

}

}

my.l即为lex程序。输入一段带有注释的java源程序，然后打入结束标志$号，回车就可以看到在输出的程序中所有注释都已经删除，在含有java文档注释的地方加上了一句注释：/*there is a Java Doc Comment*/。

经过仔细研究发现，上面的实现过程还是过分依赖C语言，没有真正发挥Lex模式匹配的强大功能。单行注释、普通多行注释、Java文档注释可分别由下列模式匹配：

.*/n

///*[^/*//]*/*//

///*/*[^/*//]*/*//

本程序还提供了识别类定义的功能，匹配模式如下：

public[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/]}*/}

(public|protected|private)[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/]}*/}

[ /n/t]*class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/]}*/}

经完善后的lex程序如下所示：

%{

#include

char * code = "";

int codelines = 0;

int classnum = 0;

int pubclass = 0;

char * classes[4]={"","","",""};

/*add a char c to the string code*/

char * add(char * code,char c)

{

char * temp;

if(code==NULL)

return "";

temp = (char*)malloc(sizeof(char)*2);

temp[0] = c;

temp[1] = '/0';

temp = strcat(code,temp);

return temp;

}

%}

%%

///*[^/*//]*/*// code = add(code,'');

///*/*[^/*//]*/*// code = strcat(code,"/*there is a Java Doc Comment*//n");

.*/n code = add(code,'/n');

public[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/}]*/} {

classes[classnum] = (char*)malloc(100);

classes[classnum] = strcpy(classes[classnum],yytext);

classnum++;

code = strcat(code,yytext);

pubclass++;

}

(public|protected|private)[ /n/t]+class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/}]*/} {

classes[classnum] = (char*)malloc(100);

classes[classnum] = strcpy(classes[classnum],yytext);

classnum++;

code = strcat(code,yytext);

}

[ /n/t]*class[ /n/t]+[a-zA-Z][_a-zA-z0-9]*/[ /n/t]*/{[^/}]*/} {

classes[classnum] = (char*)malloc(100);

classes[classnum] = strcpy(classes[classnum],yytext);

classnum++;

code = strcat(code,yytext);

}

/n code = add(code,'/n');

. {

if(yytext[0] == ';')

codelines++;

code = add(code,yytext[0]);

}

%%

yywrap()

{

int i=0;

printf("/nBelow is the code without comment:/n/n");

printf(code);

printf("/n/nConclude:/nThis code weights %d lines/n",codelines);

printf("This code includes %d classes/n",classnum);

printf("classes:/n");

for(i=0;i

{

printf(classes[i]);

printf("/n");

}

if(pubclass>1)

printf("/nThere is an error: a java file cannot have two public class/n");

code = (char*)malloc(1);

code[0]='/0';

}

main()

{

yylex();

system("pause");

return 1;

}

这个程序还有另外两个其他功能：1、根据程序的行数来确定程序工作量，行数等于分号的个数。在结果的末尾将会显示行数；2、我们知道一个java文件中不能存在两个public类，本程序可以检查一个文件中存在几个类，并判断是否存在两个或两个以上的public类，如果存在就报错。

注：my.l文件是改进前的lex程序，改进后的程序保存在my1.l文件中，Java.txt内含有一个java源程序可以用来测试。运行lexyy.exe，复制java.txt里面的内容粘贴到程序里，加上输入结束符Ctrl+z，然后回车即可看到结果；或者在dos下把java.txt作为lexyy.exe的参数运行lexyy.exe也可。

已赞过

已踩过<

你对这个回答的评价是？

评论

收起

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

输出结果如下：

输出结果(a).PNG

输出结果(b).PNG

输出结果(c).PNG

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

代码如下：

package Yue.LexicalAnalyzer;

import java.io.*;

/*

* 主程序

*/

public class Main {

public static void main(String[] args) throws IOException {

Lexer lexer = new Lexer();

lexer.printToken();

lexer.printSymbolsTable();

}

}

package Yue.LexicalAnalyzer;

import java.io.*;

import java.util.*;

/*

* 词法分析并输出

*/

public class Lexer {

/*记录行号*/

public static int line = 1;

/*存放最新读入的字符*/

char character = ' ';

/*保留字*/

Hashtable keywords = new Hashtable();

/*token序列*/

private ArrayList tokens = new ArrayList();

/*符号表*/

private ArrayList symtable = new ArrayList();

/*读取文件变量*/

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 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;

}

}

package Yue.LexicalAnalyzer;

/*

* Token父类

*/

public class Token {

public final int tag;

public int line = 1;

public String name = "";

public int pos = 0;

public Token(int t) {

this.tag = t;

}

public String toString() {

return "" + (char) tag;

}

}

package Yue.LexicalAnalyzer;

/*

* 单词类别赋值

*/

public class Tag {

public final static int

BEGIN = 1, //保留字

END = 2, //保留字

INTEGER = 3, //保留字

FUNCTION = 4, //保留字

READ = 5, //保留字

WRITE = 6, //保留字

IF = 7, //保留字

THEN = 8, //保留字

ELSE = 9, //保留字

SYMBOL = 11, //标识符

CONSTANT = 12, //常数

ADD = 13, //运算符 "+"

SUB = 14, //运算符 "-"

MUL = 15, //运算符 "*"

DIV = 16, //运算符 "/"

LE = 18, //运算符 "<="

GE = 19, //运算符 ">="

NE = 20, //运算符 "!="

ASSIGN = 23, //运算符 ":="

LPAR = 24, //界符 "("

RPAR = 25, //界符 ")"

SEM = 26, //界符 ";"

LINE_END = 27, //行尾符

ALL_END = 28; //结尾符 "#"

}

package Yue.LexicalAnalyzer;

/**

* 保留字

*/

public class KeyWord extends Token {

public String lexme = "";

public KeyWord(String s, int t) {

super(t);

this.lexme = s;

this.name = "保留字";

}

public String toString() {

return this.lexme;

}

public static final KeyWord

begin = new KeyWord("begin", Tag.BEGIN),

end = new KeyWord("end", Tag.END),

integer = new KeyWord("integer", Tag.INTEGER),

function = new KeyWord("function", Tag.FUNCTION),

read = new KeyWord("read", Tag.READ),

write = new KeyWord("write", Tag.WRITE),

aIf = new KeyWord("if", Tag.IF),

aThen = new KeyWord("then", Tag.THEN),

aElse = new KeyWord("else", Tag.ELSE);

}

package Yue.LexicalAnalyzer;

/*

* 标识符

*/

public class Symbol extends Token {

public String lexme = "";

public Symbol(String s) {

super(Tag.SYMBOL);

this.lexme = s;

this.name = "标识符";

}

public String toString() {

return this.lexme;

}

}

package Yue.LexicalAnalyzer;

/**

* 运算符

*/

public class CalcWord extends Token {

public String lexme = "";

public CalcWord(String s, int t) {

super(t);

this.lexme = s;

this.name = "运算符";

}

public String toString() {

return this.lexme;

}

public static final CalcWord

add = new CalcWord("+", Tag.ADD),

sub = new CalcWord("-", Tag.SUB),

mul = new CalcWord("*", Tag.MUL),

div = new CalcWord("/", Tag.DIV),

le = new CalcWord("<=", Tag.LE),

ge = new CalcWord(">=", Tag.GE),

ne = new CalcWord("!=", Tag.NE),

assign = new CalcWord(":=", Tag.ASSIGN);

}

package Yue.LexicalAnalyzer;

/**

* 界符

*/

public class Delimiter extends Token {

public String lexme = "";

public Delimiter(String s, int t) {

super(t);

this.lexme = s;

this.name = "界符";

}

public String toString() {

return this.lexme;

}

public static final Delimiter

lpar = new Delimiter("(", Tag.LPAR),

rpar = new Delimiter(")", Tag.RPAR),

sem = new Delimiter(";", Tag.SEM);

}

package Yue.LexicalAnalyzer;

/*

* 常数

*/

public class Num extends Token {

public final int value;

public Num(int v) {

super(Tag.CONSTANT);

this.value = v;

this.name = "常数";

}

public String toString() {

return "" + value;

}

}

package Yue.LexicalAnalyzer;

/**

* 行尾符

*/

public class LineEnd extends Token {

public String lexme = "";

public LineEnd(String s) {

super(Tag.LINE_END);

this.lexme = s;

this.name = "行尾符";

}

public String toString() {

return this.lexme;

}

public static final LineEnd lineEnd = new LineEnd("\r\n");

}

package Yue.LexicalAnalyzer;

/**

* 结尾符

*/

public class AllEnd extends Token {

public String lexme = "";

public AllEnd(String s) {

super(Tag.ALL_END);

this.lexme = s;

this.name = "结尾符";

}

public String toString() {

return this.lexme;

}

public static final AllEnd allEnd = new AllEnd("#");

}

总结

以上就睡这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流。

您可能感兴趣的文章: