javacc 语义分析

已于 2022-03-06 22:38:21 修改
阅读量3.6k 收藏 24
点赞数 10
分类专栏： javacc 编译原理 文章标签： 编译器
于 2022-01-16 20:47:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_58013827/article/details/122528527
版权

javacc 语义分析

在词法和语法分析的基础上添加语义子程序，并且掌握“拉链”、“回填”操作的原理以及实现；并且针对测试代码，输出四元式序列。

仍然是使用和语法分析相同的MiniC语法作为参考文法。

<程序> ->Type main(){<语句块>*}

<语句块> -> <语句>|{<语句块>*}

<语句> -> <顺序语句>|<条件语句>|<循环语句>

<顺序语句> ->(<声明语句>|<赋值语句>)”;”

<声明语句> ->Type ID,ID,…,ID

<赋值语句> ->ID =<表达式>

<条件语句> ->if(<条件>)<语句块>else<语句块>

<循环语句> ->while(<条件>)<语句块>

<逻辑> -><条件>(<逻辑运算符><条件>)*

<条件> -><表达式>(<关系符><表达式>)?

<表达式> ->//可以使用默认的

<关系符> -><|<=|>|>=|==|!=

<逻辑运算> ->&& | || （包含在逻辑中）

修改.jjt文件中的main方法，使其执行任务是：指定要进行语义分析的源程序，执行语义分析，输出四元式到文件中。

要想好编译程序的结构，除了JavaCC生成的类，还需要哪些辅助类。如四元式类、四元式链表类、自动产生临时变量的类等。这里的四个类都可以使用所给的类，直接添加到项目进行使用。

为了使得输出的四元式子在文件中而不输出语法树，我们可以选择将QTList类中的printQTTable方法进行修改。

 public void printQTTable() {
         // System.out.println(toString());
         Iterator<QTInfo> itr = QTList.iterator();
         try {
             FileWriter fw = new FileWriter("./result.txt",true);
             BufferedWriter bw = new BufferedWriter(fw);
             while (itr.hasNext()) {
                 QTInfo tmp = (QTInfo) itr.next();
                 //System.out.println(tmp.toString());
                 bw.write(tmp.toString());
                 bw.newLine();
             }
             bw.close();
             fw.close();
             
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

在.jjt文件中添加Minic文法表达式

 
SimpleNode Start() :
 {}
 {
   Program()
   //AdditiveExpression()
   {
     return jjtThis;
   }
 }
 void Program() ://主程序
 {}
 {
 Type()
   < MAIN >
   < LB >
   < RB >
   < BLB >
   (
     SentenceBlock()
     )*
 //    (ReturnSentence()
 //    )
     < BRB >
 }
 void Type() ://类别
 {}
 {
  < INT >
 | < VOID >
 | < STRING >
 | < CHAR >
 | < DOUBLE >
 | < FLOAT >
 }
 void ReturnSentence()://返回
 {}
 {
 < RETURN > <INTEGER_LITERAL> < SEMICOLON>
 }
 ​
 void SentenceBlock() ://语句块
 {}
 {
     Sentence()
 | < BLB > (SentenceBlock())* < BRB >
 }
 void Sentence() ://语句
 {}
 {
   SequenceSentence()
 | ConditionSentence()
 | LoopSentence()
 ​
 }
 void SequenceSentence() ://顺序语句
 {}
 {
     StateSentence() < SEMICOLON >
   | AssignSentence() < SEMICOLON >
 }
 void StateSentence() ://声明语句
 {}
 {
  Type()
 Identifier() (< COMMA > Identifier())*
 }
 void AssignSentence() ://赋值语句
 {
   String str2=null,str1=null;
   Token op;
 }
 {
   str1 = Identifier()
   op = "="
   str2 = Expression()
   {
     QTInfo qt = new QTInfo(op.image,str2,"_",str1);
     qtList.addQTInfo(qt);
   }
 }
 ​
 ​
 ​
 ​
 void ConditionSentence()://条件语句
 {
   int QTSize = QTInfo.size;
   ConditionValue Value = null;
 }
 {
   < IF >< LB >
     (
       Value = ifCondition()
     )
   < RB >
   {
     Value.backpatchTrueChain(QTInfo.size+1);
   }
   SentenceBlock()
   {
     Value.backpatchFalseChain(QTInfo.size+1);
   }
   (
    
     < ELSE >
     {
      QTInfo qt = new QTInfo("J","_","_","T");
      qtList.addQTInfo(qt);
      Value.mergeTrue(qt);
     }
   SentenceBlock()
     {
       Value.backpatchTrueChain(QTInfo.size+1);
       Value.backpatchFalseChain(QTInfo.size);
    
     }
   )?
 }
 ConditionValue Condition() ://循环条件
 {
     ConditionValue Value = new ConditionValue();
     String str1 = null,str2 = null;
     Token op = null; 
 }
 {
   str1 = Expression()(
     (
     op = ">"
   |op = "<"
   |op = ">="
   |op = "<="
   |op = "!="
   |op = "||"
   |op = "&&"
   )
   
     str2 = Expression())?
 {
   QTInfo qt1 = new QTInfo("J"+op.image,str1,str2,"_");
   qtList.addQTInfo(qt1);
   QTInfo qt2 = new QTInfo("J","_","_","_");
   qtList.addQTInfo(qt2);
   Value.mergeTrue(qt1);
   Value.mergeFalse(qt2);
   return Value;
 //  QTInfo qt1;
 //  if(str2 != "")
 //      qt1 = new QTInfo("J"+op.image,str1,str2,"_");
 //  else
 //    qt1 = new QTInfo("Jnz",str1,"_","_");
 //  qtList.addQTInfo(qt1);
 //  QTInfo qt2 = new QTInfo("J","_","_","_");
 //  qtList.addQTInfo(qt2);
 //  Value.mergeTrue(qt1);
 //  Value.mergeFalse(qt2);
 //  return Value;
 }
 }
 ConditionValue ifCondition() ://判定条件
 {
     ConditionValue Value = new ConditionValue();
     String str1 = null,str2 = null;
     Token op = null;
     int qtSize = QTInfo.size;
 }
 {
   str1 = Expression()(
     (
     op = ">"
   |op = "<"
   |op = ">="
   |op = "<="
   |op = "!="
   |op = "||"
   |op = "&&"
   )
   
     str2 = Expression())?
 {
 ​
   QTInfo qt1;
   
   if(op != null) { 
     qt1 = new QTInfo("J"+op.image,str1,str2,QTInfo.size+3);
     qtList.addQTInfo(qt1);
     //Value.mergeTrue(qt1);
  }
   else { 
     qt1 = new QTInfo("Jnz",str1,"_",QTInfo.size+3);
     qtList.addQTInfo(qt1);
     //Value.mergeTrue(qt1);
   }
   
   QTInfo qt2 = new QTInfo("J","_","_","F");
   qtList.addQTInfo(qt2);
   
   Value.mergeFalse(qt2);
   return Value;
 }
 }
 void LoopSentence()://循环语句
 {
   int QTSize = QTInfo.size;
   ConditionValue Value = null;
 }
 {
     < WHILE >
     < LB >
     Value = Condition()
     < RB >
     {
         Value.backpatchTrueChain(QTInfo.size+1);
     }
     SentenceBlock()
     {
       QTInfo qt = new QTInfo("J","_","_",QTSize+1);
       qtList.addQTInfo(qt);
       Value.backpatchFalseChain(QTInfo.size+1);
     }
 }
 String Expression() ://表达式
 {String str;}
 {
  str = AdditiveExpression()
  {
    return str;
  }
 }
 ​
 String AdditiveExpression() :
 {
   String str1,str2;
   String newTemp;
   Token op;
 }
 {
   str1 = MultiplicativeExpression()
   {
     newTemp = str1;
   }
   (
     (
       op = "+"
     | op = "-"
     )
   str2 = MultiplicativeExpression()
   {
     newTemp = VariableNameGenerator.genVariableName();
     QTInfo qt = new QTInfo(op.image,str1,str2,newTemp);
     qtList.addQTInfo(qt);
     str1 = newTemp;
   }
   )*
   {
     return newTemp;
   }
 }
 ​
 String MultiplicativeExpression() :
 {
   String str1,str2;
   String newTemp;
   Token op;
 }
 {
   str1 = UnaryExpression()
   {
     newTemp = str1;
   }
   (
     (
       op = "*"
     | op = "/"
     | op = "%"
     )
   str2 = UnaryExpression()
   {
     newTemp = VariableNameGenerator.genVariableName();
     QTInfo qt = new QTInfo(op.image,str1,str2,newTemp);
     qtList.addQTInfo(qt);
     str1 = newTemp;
   }
   )*
   {
     return newTemp;
   }
 }
 ​
 String UnaryExpression() :
 {String str = null;}
 {
     (
     
         "(" str = Expression() ")"
         | str = Identifier()
         | str = Integer()
         | str = Constant()
     )
     {
       return str;
     }
 }
 ​
 ​
 String Identifier() :
 {Token t = null;}
 {
   t = < IDENTIFIER >
   {
     return t.image;
   }
 }
 ​
 String Integer() :
 {Token t = null;}
 {
   t = < INTEGER_LITERAL >
   {
     return t.image;
   }
 }
 String Constant() :
 {Token t =null;}
 {
   t = < CONSTANT >
   {
     return t.image;
   }
 }

测试代码和生成的四元式如下：

完整的jjt文件如下：

 

/**
  * JJTree template file created by SF JavaCC plugin 1.5.28+ wizard for JavaCC 1.5.0+
  */
 options
 {
   static = true;
 }
 ​
 PARSER_BEGIN(MyNewGrammar)
 package byylworkform3;
 import utils.*;
 import java.io.FileInputStream;
 public class MyNewGrammar
 {
   static QTList qtList = new QTList();
   public void printQTList() {
     qtList.printQTTable();
   }
   public static void main(String args [])
   {
 //    System.out.println("Reading from standard input...");
 //    System.out.print("Enter an expression like \"1+(2+3)*var;\" :");
 //    MyNewGrammar input = new MyNewGrammar(System.in);
     try
     {
       //String file = "./text1.txt";
       String file = "./text2.txt";
       //String file = "./text3.txt";
       //String file = "./text4.txt";
       FileInputStream fin = new FileInputStream(file);
       MyNewGrammar input = new MyNewGrammar(fin);
       SimpleNode n = MyNewGrammar.Start();
       input.printQTList();
       n.dump("");
       System.out.println("Thank you.");
     }
     catch (Exception e)
     {
       System.out.println("Oops.");
       System.out.println(e.getMessage());
     }
   }
 }
 ​
 PARSER_END(MyNewGrammar)
 ​
 SKIP :
 {
   " "
 | "\t"
 | "\n"
 | "\r"
 | < "//" (~[ "\n", "\r" ])*
     (
       "\n"
     | "\r"
     | "\r\n"
     ) >
 | < "/*" (~[ "*" ])* "*"
     (
       ~[ "/" ] (~[ "*" ])* "*"
     )*
     "/" >
 }
 ​
 TOKEN : /* LITERALS */
 {
   < INTEGER_LITERAL :
     < DECIMAL_LITERAL > ([ "l", "L" ])?
   | < HEX_LITERAL > ([ "l", "L" ])?
   | < OCTAL_LITERAL > ([ "l", "L" ])? 
     >
 | < #DECIMAL_LITERAL : [ "1"-"9" ] ([ "0"-"9" ])* >
 | < #HEX_LITERAL : "0" [ "x", "X" ] ([ "0"-"9", "a"-"f", "A"-"F" ])+ >
 | < #OCTAL_LITERAL : "0" ([ "0"-"7" ])* >
 }
 ​
 TOKEN :
 {
   < CONSTANT :
     (< DIGIT >)+
     (
       "." (< DIGIT >)+
     )? >
 }
 ​
 TOKEN : /* KEYWORDS */
 {
     < MAIN : "main" >
 |   < INT : "int" >
 |  < RETURN :"return" >
 | < IF:"if" >
 | < ELSE:"else" >
 | < VOID : "void" >
 | < DOUBLE:"double" >
 | < FLOAT:"float" >
 | < WHILE:"while" >
 | < DO:"do" >
 | < FOR:"for" >
 | < CHAR:"char" >
 | < STRING:"string" >
 | < BOOL:"bool" >
 }
 ​
 TOKEN: /*OPERATORS*/
 {
     < PLUS : "+" >
 |   < MINUS : "-" >
 |   < MULTIPLY : "*" >
 |   < DIVIDE : "/" >
 | < GD:">" >
 | < LD:"<" >
 | < SQRT:"^" >
 | < EQ:"=" >
 | < GE:">=" >
 | < LE:"<=" >
 | < EQQ:"==" >
 | < NE:"!=" >
 | < ANDD:"&&" >
 | < ORR:"||" >
 }
 TOKEN: /* SEPARATER */
 {
 < COMMA:"," >
 | < SEMICOLON:";" >
 | < LB:"(" >
 | < RB:")" >
 | < BLB:"{" >
 | < BRB:"}" >
 | < LBB:"[" >
 | < RBB:"]" >
 ​
 }
 TOKEN : /* IDENTIFIERS */
 {
   < IDENTIFIER :
     < LETTER >
     (
       < LETTER >
     | < DIGIT >
     )* >
 | < #LETTER : [ "_", "a"-"z", "A"-"Z" ] >
 | < #DIGIT : [ "0"-"9" ] >
 }
 ​
 SimpleNode Start() :
 {}
 {
   Program()
   //AdditiveExpression()
   {
     return jjtThis;
   }
 }
 void Program() ://主程序
 {}
 {
 Type()
   < MAIN >
   < LB >
   < RB >
   < BLB >
   (
     SentenceBlock()
     )*
 //    (ReturnSentence()
 //    )
     < BRB >
 }
 void Type() ://类别
 {}
 {
  < INT >
 | < VOID >
 | < STRING >
 | < CHAR >
 | < DOUBLE >
 | < FLOAT >
 }
 void ReturnSentence()://返回
 {}
 {
 < RETURN > <INTEGER_LITERAL> < SEMICOLON>
 }
 ​
 void SentenceBlock() ://语句块
 {}
 {
     Sentence()
 | < BLB > (SentenceBlock())* < BRB >
 }
 void Sentence() ://语句
 {}
 {
   SequenceSentence()
 | ConditionSentence()
 | LoopSentence()
 ​
 }
 void SequenceSentence() ://顺序语句
 {}
 {
     StateSentence() < SEMICOLON >
   | AssignSentence() < SEMICOLON >
 }
 void StateSentence() ://声明语句
 {}
 {
  Type()
 Identifier() (< COMMA > Identifier())*
 }
 void AssignSentence() ://赋值语句
 {
   String str2=null,str1=null;
   Token op;
 }
 {
   str1 = Identifier()
   op = "="
   str2 = Expression()
   {
     QTInfo qt = new QTInfo(op.image,str2,"_",str1);
     qtList.addQTInfo(qt);
   }
 }
 ​
 ​
 ​
 ​
 void ConditionSentence()://条件语句
 {
   int QTSize = QTInfo.size;
   ConditionValue Value = null;
 }
 {
   < IF >< LB >
     (
       Value = ifCondition()
     )
   < RB >
   {
     Value.backpatchTrueChain(QTInfo.size+1);
   }
   SentenceBlock()
   {
     Value.backpatchFalseChain(QTInfo.size+1);
   }
   (
    
     < ELSE >
     {
      QTInfo qt = new QTInfo("J","_","_","T");
      qtList.addQTInfo(qt);
      Value.mergeTrue(qt);
     }
   SentenceBlock()
     {
       Value.backpatchTrueChain(QTInfo.size+1);
       Value.backpatchFalseChain(QTInfo.size);
    
     }
   )?
 }
 ConditionValue Condition() ://循环条件
 {
     ConditionValue Value = new ConditionValue();
     String str1 = null,str2 = null;
     Token op = null; 
 }
 {
   str1 = Expression()(
     (
     op = ">"
   |op = "<"
   |op = ">="
   |op = "<="
   |op = "!="
   |op = "||"
   |op = "&&"
   )
   
     str2 = Expression())?
 {
   QTInfo qt1 = new QTInfo("J"+op.image,str1,str2,"_");
   qtList.addQTInfo(qt1);
   QTInfo qt2 = new QTInfo("J","_","_","_");
   qtList.addQTInfo(qt2);
   Value.mergeTrue(qt1);
   Value.mergeFalse(qt2);
   return Value;
 //  QTInfo qt1;
 //  if(str2 != "")
 //      qt1 = new QTInfo("J"+op.image,str1,str2,"_");
 //  else
 //    qt1 = new QTInfo("Jnz",str1,"_","_");
 //  qtList.addQTInfo(qt1);
 //  QTInfo qt2 = new QTInfo("J","_","_","_");
 //  qtList.addQTInfo(qt2);
 //  Value.mergeTrue(qt1);
 //  Value.mergeFalse(qt2);
 //  return Value;
 }
 }
 ConditionValue ifCondition() ://判定条件
 {
     ConditionValue Value = new ConditionValue();
     String str1 = null,str2 = null;
     Token op = null;
     int qtSize = QTInfo.size;
 }
 {
   str1 = Expression()(
     (
     op = ">"
   |op = "<"
   |op = ">="
   |op = "<="
   |op = "!="
   |op = "||"
   |op = "&&"
   )
   
     str2 = Expression())?
 {
 ​
   QTInfo qt1;
   
   if(op != null) { 
     qt1 = new QTInfo("J"+op.image,str1,str2,QTInfo.size+3);
     qtList.addQTInfo(qt1);
     //Value.mergeTrue(qt1);
  }
   else { 
     qt1 = new QTInfo("Jnz",str1,"_",QTInfo.size+3);
     qtList.addQTInfo(qt1);
     //Value.mergeTrue(qt1);
   }
   
   QTInfo qt2 = new QTInfo("J","_","_","F");
   qtList.addQTInfo(qt2);
   
   Value.mergeFalse(qt2);
   return Value;
 }
 }
 void LoopSentence()://循环语句
 {
   int QTSize = QTInfo.size;
   ConditionValue Value = null;
 }
 {
     < WHILE >
     < LB >
     Value = Condition()
     < RB >
     {
         Value.backpatchTrueChain(QTInfo.size+1);
     }
     SentenceBlock()
     {
       QTInfo qt = new QTInfo("J","_","_",QTSize+1);
       qtList.addQTInfo(qt);
       Value.backpatchFalseChain(QTInfo.size+1);
     }
 }
 String Expression() ://表达式
 {String str;}
 {
  str = AdditiveExpression()
  {
    return str;
  }
 }
 ​
 String AdditiveExpression() :
 {
   String str1,str2;
   String newTemp;
   Token op;
 }
 {
   str1 = MultiplicativeExpression()
   {
     newTemp = str1;
   }
   (
     (
       op = "+"
     | op = "-"
     )
   str2 = MultiplicativeExpression()
   {
     newTemp = VariableNameGenerator.genVariableName();
     QTInfo qt = new QTInfo(op.image,str1,str2,newTemp);
     qtList.addQTInfo(qt);
     str1 = newTemp;
   }
   )*
   {
     return newTemp;
   }
 }
 ​
 String MultiplicativeExpression() :
 {
   String str1,str2;
   String newTemp;
   Token op;
 }
 {
   str1 = UnaryExpression()
   {
     newTemp = str1;
   }
   (
     (
       op = "*"
     | op = "/"
     | op = "%"
     )
   str2 = UnaryExpression()
   {
     newTemp = VariableNameGenerator.genVariableName();
     QTInfo qt = new QTInfo(op.image,str1,str2,newTemp);
     qtList.addQTInfo(qt);
     str1 = newTemp;
   }
   )*
   {
     return newTemp;
   }
 }
 ​
 String UnaryExpression() :
 {String str = null;}
 {
     (
     
         "(" str = Expression() ")"
         | str = Identifier()
         | str = Integer()
         | str = Constant()
     )
     {
       return str;
     }
 }
 ​
 ​
 String Identifier() :
 {Token t = null;}
 {
   t = < IDENTIFIER >
   {
     return t.image;
   }
 }
 ​
 String Integer() :
 {Token t = null;}
 {
   t = < INTEGER_LITERAL >
   {
     return t.image;
   }
 }
 String Constant() :
 {Token t =null;}
 {
   t = < CONSTANT >
   {
     return t.image;
   }
 }
 ​
语义分析实验(java版）
12-16
通过上机实习，加深对语法制导翻译原理的理解，掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法。 采用递归下降语法制导翻译法，对算术表达式、赋值语句进行语义分析并生成四元式序列。
java 语义分析_Java代码分析器(五): 语义分析简介
weixin_27722377的博客
02-12 1350
本系列临近尾声，科技树到此点满。语法分析主要用库解决了，代码变成了一棵树，但是变量类型，方法签名之类的东东都不清楚。如果做IDE插件，可以享受IDE的语义分析能力。为了让程序独立运行，我自己按需实现了语义分析。比较复杂，就分享一种最典型的吧。贴代码为主，有问题请告诉我，我再改文章。解析某个变量的声明类型，会上溯当前方法和类，以及祖先类。为了提速(分析大型代码库)，可以手动限制范围。直接贴代码了，已...
java版语义解析
12-04
java版的科大讯飞api，有详细的说明，以及做了很多优化
java语义分析
最新发布
weixin_73808948的博客
05-28 357
秉承开源精神，供读者学习
编译原理语义分析java实现
03-28
编译原理语义分析java实现程序报告，由语法和此分析衍生而来，生成四元式输出
javacc语义分析.zip
01-16
在“javacc语义分析.zip”文件中，我们可以期待找到与JavaCC相关的语义分析相关内容。语义分析是编译器设计中的一个关键阶段，它发生在词法分析和语法分析之后，主要任务是检查程序的逻辑含义，确保程序符合编程语言...
JavaCC语义分析实验报告：深入理解语法解析
资源摘要信息: "javacc语义分析.zip" 知识点一：JavaCC（Java Compiler）基础 JavaCC是一种用于生成编译器的工具，它能够将语法描述文件（通常以.jj为扩展名）转换为Java源代码。JavaCC的特点是易于编写和修改，...
编译原理中用javacc实现MiniC的词法分析、语法分析、语义分析
02-23
用Javacc实现MiniC的词法分析、语法分析、语义分析。在词法分析部分根据单词的构词规则分类，输出<单词种别，单词自身值>二元式；在语法分析部分利用Javacc实现LL(1)文法，判断源语言是否符合MiniC的语法，如果不...
基于MiniC的语义分析（Javacc实现）
01-01
本项目聚焦于其中的“语义分析”阶段，采用JavaCC工具实现了一个基于MiniC的编译器前端。MiniC是一种简化版的C语言，用于教学和实践编译器设计。 JavaCC（Java Compiler Compiler）是一款强大的、开源的Java解析器...
编译原理实验三语义分析JavaCC代码
06-28
通过上机实习，加深对语法制时翻译原理的理解，掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法。...采用递归下降语法制导翻译法对算术表达式、赋值语句、条件语句、循环语句进行语义分析生成四元式序列。
Java语言子集语法、语义分析器
06-16
1. 完成对附录一中文法描述的Java源代码的语法分析、语义分析及代码生成。代码生成的目标代码为MASM汇编代码； 2. 词法分析使用实验一完成的词法分析器（即与词法分析器有直接接口）； 3. 课程考试前通过网络教室提交（包括源码和可执行文件的压缩文件 4. 通过测试用例的验收；
semantic-analyzer:Java语义分析器应用程序，用于Java编程语言的子集
05-16
语义分析器 Java编程语言的子集的语义分析器。 ：语义分析（也包括上下文敏感分析）是编译器构造过程中的一个过程，通常在解析后从源代码中收集必要的语义信息。 它通常包括类型检查，或确保在使用前声明了一个变量，该变量无法用扩展Backus–Naur形式描述，因此在解析过程中不容易检测到。 先决条件： 该应用程序是使用Java构建的，因此您应该在计算机上安装才能运行它。 特征： 词法分析。 语法分析（解析）。 语义分析。 用法： 将此存储库下载或克隆到您的计算机。 编译并运行带有命令行参数的任何Tester类（Testlexer，TestParser或TestSemantic）都指向测试文件路径。 javac Testlexer . java java Testlexer test_file_path 或者 javac TestParser . java java TestP
java实现简单的编译原理词法语法语义分析程序
05-26
一个一遍扫描的词法语法语义分析程序，将部分C语言的语法成分翻译成三地址代码，要求有一定的出错提示和错误恢复功能
java实现的pascal语义分析器
10-22
基于java的语义分析器，eclipse中编译。 并且有简单的执行功能，使用时请注意所要分析的代码的路径， 可在代码中搜索改路径找到并修改，结果显示在控制台中。
LatentSemanticAnalysis:Java 中的潜在语义分析实现
06-02
潜在语义分析 遵循以下论文给出的教程，Java 中的潜在语义分析实现： 如果链接断开，您可以阅读此存储库中文件“LSA_Tutorial.pdf”中的论文。
用java做语义分析_14.Java语义分析与字节码生成
weixin_33130113的博客
03-04 1201
1. 标注检查标注检查步骤检查的内容包括如变量的使用前是否已被声明、变量与复制之间的数据类型是否能够匹配等。以及常量折叠，//在编译期间会将以下代码转换为int a=3;int a= 1+2;2. 数据及控制流分析数据及控制流分析是对程序上下文逻辑更进一步的验证，它可以监察处注入程序局部变量在使用前是否有复制、方法的每条路径是否都有返回值、是否所有的受查异常都被正确处理了等问题。//方法一带有fi...
java语言实现语义分析器,Javac工作原理分析(3):语义分析器
weixin_33447647的博客
03-12 1140
java代码经过词法分析器和语法分析器后形成一棵结构化、可造作的语法树，但是这棵语法树太粗糙了，离我们的目标java代码字节码的产生还有点差距。必须要在这棵语法树的基础上在做一些处理，如给类添加默认的构造函数，检查变量在使用前是否已经初始化，将一些常来进行合并处理，检查操作变量类型是否匹配，检查所有的操作语句是否可达，检查checked exception异常是否已经捕获或抛出，解除Java的语法...
java语言实现语义分析器,Java语言语法语义分析器设计与实现
weixin_42518874的博客
03-12 1552
Java语言词法分析器的设计与实现一．实验目的1．强化对系统软件综合工程实现能力、规划能力的训练；2．加强对词法分析原理、方法和基本实现技术的理解；二．实验内容用C语言(或 C++ )作为宿主语言完成：其中具体要求：1.使用DFA实现词法分析器的设计；2.实现对Java源程序中注释的过滤；3.利用两对半缓冲区从文件中逐一读取单词；4.词法分析结果属性字流存放在独立文件(文件名：scanner_ou...
java编译原理语义分析_编译原理实验六：语义分析器
weixin_35942549的博客
02-28 1703
(一)学习经典的语义分析器(2小时)实验目的学习已有编译器的经典语义分析源程序。实验任务阅读已有编译器的经典语义分析源程序，并测试语义分析器的输出。实验内容(1)选择一个编译器，如：TINY或PL/0，其它编译器也可(需自备源代码)。(2)阅读语义分析源程序，加上你自己的理解。尤其要求对相关函数与重要变量的作用与功能进行稍微详细的描述。若能加上学习心得则更好。TINY语言请参考《编译原理及实践》第...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值