[educoder] 编译原理 用JAVACC生成并扩充C语言的语法分析器（三）

最新推荐文章于 2021-02-28 14:06:29 发布
最新推荐文章于 2021-02-28 14:06:29 发布
阅读量2.2k 收藏 3
点赞数 5
分类专栏： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45225566/article/details/112505874
版权

第3关 用JavaCC为C语言扩充SQL语句

 /* 名称：	用JavaCC生成C语言的语法分析器(扩展SQL语言)														*/
 /* 功能：	用JavaCC实现一个C语言的语法分析器																*/
 /* 说明：	在下面的合适位置中添加代码，需要增加对SQL语言的支持:											*/
 /* 																										*/
 /* 			sql{SequenceOfSQLStatements};																*/
 /* 																										*/
 /*			其中SequenceOfSQLStatements在任务描述中已经给出。												*/
 /* 提示：	阅读JavaCC提供的Grammar Repository(https://javacc.org/grammar-library) 中的C.JJ的代码			*/
 /*       	参考JavaCC提供的Grammar Repository(https://javacc.org/grammar-library) 中的PlSql.JJ的代码		*/

PARSER_BEGIN(CSQLParser)

import java.util.*;

  public class CSQLParser{

    // Hastable for storing typedef types
    private static Set types = new HashSet();

    // Stack for determining when the parser
    // is parsing a typdef definition.
    private static Stack typedefParsingStack = new Stack();

    // Returns true if the given string is
    // a typedef type.
    private static boolean isType(String type){
   	  return types.contains(type);
    }

    // Add a typedef type to those already defined
    private static void addType(String type){
   	  types.add(type);
    }

    // Prints out all the types used in parsing the c source
    private static void printTypes(){
      for (Iterator i = types.iterator(); i.hasNext();) {
        System.out.println(i.next());
      }
    }

    // Run the parser
    public static void main ( String args [ ] ) {
      CSQLParser parser ;

  	  // Hack to include type "special types"
	    types.add("__signed__");
	    types.add("__const");
	    types.add("__inline__");
	    types.add("__signed");

      if(args.length == 0){
        System.out.println("CSQL Parser Version 0.1Alpha:  Reading from standard input . . .");
        parser = new CSQLParser(System.in);
      }
      else if(args.length == 1){
        System.out.println("CSQL Parser Version 0.1Alpha:  Reading from file " + args[0] + " . . ." );
      try {
        parser = new CSQLParser(new java.io.FileInputStream(args[0]));
      }
      catch(java.io.FileNotFoundException e){
        System.out.println("CSQL Parser Version 0.1:  File " + args[0] + " not found.");
        return ;
        }
      }
      else {
        System.out.println("CSQL Parser Version 0.1Alpha:  Usage is one of:");
        System.out.println("         java CSQLParser < inputfile");
        System.out.println("OR");
        System.out.println("         java CSQLParser inputfile");
        return ;
      }
      try {
        parser.TranslationUnit();
        System.out.println("CSQL Parser Version 0.1Alpha:  Java program parsed successfully.");
      }
      catch(ParseException e){
        System.out.println("CSQL Parser Version 0.1Alpha:  Encountered errors during parse.");
        e.printStackTrace();
      }
    }
  }

PARSER_END(CSQLParser)

SKIP : {
 " "
|  "\t"
|  "\n"
|  "\r"
|  <"//" (~["\n","\r"])* ("\n" | "\r" | "\r\n")>
|  <"/*" (~["*"])* "*" ("*" | ~["*","/"] (~["*"])* "*")* "/">
| "#" : PREPROCESSOR_OUTPUT
}

<PREPROCESSOR_OUTPUT> SKIP:
{
     "\n" : DEFAULT
}

<PREPROCESSOR_OUTPUT> MORE:
{
 "\\\n"
 |
 "\\\r\n"
 |
 < ~[] >
}


TOKEN : {
 <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"])*>
|  <FLOATING_POINT_LITERAL: (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])? | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])? | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])? | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]>
|  <#EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+>
|  <CHARACTER_LITERAL: "\'" (~["\'","\\","\n","\r"] | "\\" (["n","t","b","r","f","\\","\'","\""] | ["0"-"7"] (["0"-"7"])? | ["0"-"3"] ["0"-"7"] ["0"-"7"])) "\'">
|  <STRING_LITERAL: "\"" ( ~["\"","\\","\n","\r"] | "\\" ( ["n","t","b","r","f","\\","\'","\""] | ["0"-"7"] (["0"-"7"])?  | ["0"-"3"] ["0"-"7"] ["0"-"7"] | ( ["\n","\r"] | "\r\n")))* "\"">
}

TOKEN : {
	<OR: "or" | "OR"> |
	<AND: "and" | "AND"> |
	<FROM: "from" | "FROM"> |
	<DELETE: "delete" | "DELETE"> |
	<WHERE: ("where" | "WHERE")> |
	<INSERT: ("insert" | "INSERT")> |
	<INTO: "into" | "INTO" > |
	<VALUES: "values" | "VALUES"> |
	<SELECT: "select" | "SELECT"> |
	<UPDATE: "update" | "UPDATE"> |
	<SET: "set" | "SET"> |
	<CONTINUE: "continue"> |
	<VOLATILE: "volatile"> |
	<REGISTER: "register"> |
	<UNSIGNED: "unsigned"> |
	<TYPEDEF: "typedef"> |
	<DFLT: "default"> |
	<DOUBLE: "double"> |
	<SIZEOF: "sizeof"> |
	<SWITCH: "switch"> |
	<RETURN: "return"> |
	<EXTERN: "extern"> |
	<STRUCT: "struct"> |
	<STATIC: "static"> |
	<SIGNED: "signed"> |
	<WHILE: "while"> |
	<BREAK: "break"> |
	<UNION: "union"> |
	<CONST: "const"> |
	<FLOAT: "float"> |
	<SHORT: "short"> |
	<ELSE: "else"> |
	<CASE: "case"> |
	<LONG: "long"> |
	<ENUM: "enum"> |
	<AUTO: "auto"> |
	<VOID: "void"> |
	<CHAR: "char"> |
	<GOTO: "goto"> |
	<FOR: "for"> |
	<INT: "int"> |
	<IF: "if"> |
	<DO: "do"> |
	<SQL: "sql">
}

TOKEN : {
 <IDENTIFIER: <LETTER> (<LETTER> | <DIGIT>)*>
|  <#LETTER: ["$","A"-"Z","_","a"-"z"]>
|  <#DIGIT: ["0"-"9"]>
}

void TranslationUnit() : {}
{
	(ExternalDeclaration())+
}

void ExternalDeclaration() : {}
{
	( LOOKAHEAD( FunctionDefinition() ) FunctionDefinition() | Declaration())
}


void FunctionDefinition() : {}
{
	([LOOKAHEAD(DeclarationSpecifiers()) DeclarationSpecifiers()] Declarator() [ DeclarationList() ]
	CompoundStatement())
}
void Declaration() : {}
{
	DeclarationSpecifiers() [ InitDeclaratorList() ] ";"
}

void DeclarationList() : {}
{
	( LOOKAHEAD(Declaration()) Declaration() )+
}

void DeclarationSpecifiers() : {}
{
	  StorageClassSpecifier() [ LOOKAHEAD(DeclarationSpecifiers())
	        DeclarationSpecifiers() ] |
	  TypeSpecifier()  [ LOOKAHEAD(DeclarationSpecifiers())
	        DeclarationSpecifiers() ] |
	  TypeQualifier() [ LOOKAHEAD(DeclarationSpecifiers())
	        DeclarationSpecifiers() ]
}

void StorageClassSpecifier() : {}
{
	( <AUTO> | <REGISTER> | <STATIC> | <EXTERN> | <TYPEDEF>
	{
		typedefParsingStack.push(Boolean.TRUE);
	} )
}

void TypeSpecifier() : {}
{
	( <VOID> | <CHAR> | <SHORT> | <INT> | <LONG> | <FLOAT> | <DOUBLE> | <SIGNED> |
	  <UNSIGNED> | StructOrUnionSpecifier() | EnumSpecifier() | LOOKAHEAD( { isType(getToken(1).image) } )TypedefName() )
}

void TypeQualifier() : {}
{
	( <CONST> | <VOLATILE> )
}

void StructOrUnionSpecifier() : {}
{
	{
			typedefParsingStack.push(Boolean.FALSE);
	}

	StructOrUnion() ( LOOKAHEAD(3) [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | <IDENTIFIER> )

	{
		typedefParsingStack.pop();
	}
}

void StructOrUnion() : {}
{
	( <STRUCT> | <UNION> )
}

void StructDeclarationList() : {}
{
	(StructDeclaration())+
}

void InitDeclaratorList() : {}
{
	InitDeclarator() ("," InitDeclarator())*
	{
		// Finished with a typedefDeclaration??
		if(!(typedefParsingStack.empty()) && ((Boolean)typedefParsingStack.peek()).booleanValue()){
		   	typedefParsingStack.pop();
	  }
	}
}

void InitDeclarator() : {}
{
	Declarator() [ "=" Initializer() ]
}

void StructDeclaration() : {}
{
	SpecifierQualifierList() StructDeclaratorList() ";"
}

void SpecifierQualifierList() : {}
{
	  TypeSpecifier() [ LOOKAHEAD(SpecifierQualifierList())
	        SpecifierQualifierList() ]|
	  TypeQualifier() [ LOOKAHEAD(SpecifierQualifierList())
	        SpecifierQualifierList() ]
}

void StructDeclaratorList() : {}
{
	StructDeclarator() ( "," StructDeclarator() )*
}

void StructDeclarator() : {}
{
	( LOOKAHEAD(3) Declarator() | [ Declarator() ] ":" ConstantExpression() )
}

void EnumSpecifier() : {}
{
	<ENUM> ( LOOKAHEAD(3) [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
}

void EnumeratorList() : {}
{
	Enumerator() ("," Enumerator())*
}

void Enumerator() : {}
{
	<IDENTIFIER> [ "=" ConstantExpression() ]
}

void Declarator() : {}
{
	[ Pointer() ] DirectDeclarator()
}

void DirectDeclarator() : { Token t;}
{
	( t = <IDENTIFIER>

	{ if(!(typedefParsingStack.empty()) && ((Boolean)typedefParsingStack.peek()).booleanValue()){
				addType(t.image);
	  }
	}
	 | "(" Declarator() ")" )
  
  { typedefParsingStack.push( Boolean.FALSE ); }

	( "[" [ ConstantExpression() ] "]" |
	    LOOKAHEAD(3) "(" ParameterTypeList() ")" |
	    "(" [ IdentifierList() ] ")" )*
      { typedefParsingStack.pop(); }
}

void Pointer() : {}
{
	"*" [ TypeQualifierList() ] [ Pointer() ]
}

void TypeQualifierList() : {}
{
	(TypeQualifier())+
}

void ParameterTypeList() : {}
{
	ParameterList() ["," "..." ]
}

void ParameterList() : {}
{
	ParameterDeclaration() (LOOKAHEAD(2) "," ParameterDeclaration())*
}

void ParameterDeclaration() : {}
{
	DeclarationSpecifiers() ( LOOKAHEAD(Declarator()) Declarator() | [ AbstractDeclarator() ] )
}

void IdentifierList() : {}
{
	<IDENTIFIER> ("," <IDENTIFIER>)*
}

void Initializer() : {}
{
	( AssignmentExpression() |
	  "{" InitializerList() [","] "}" )
}

void InitializerList() : {}
{
	Initializer() (LOOKAHEAD(2) "," Initializer())*
}

void TypeName() : {}
{
	SpecifierQualifierList() [ AbstractDeclarator() ]

}

void AbstractDeclarator() : {}
{
	( LOOKAHEAD(3) Pointer() |
	  [Pointer()] DirectAbstractDeclarator() )
}

void DirectAbstractDeclarator() : {}
{
	( LOOKAHEAD(2) "(" AbstractDeclarator() ")" |
	               "[" [ConstantExpression()] "]" |
	               "(" [ParameterTypeList()] ")" )

	  ( "[" [ ConstantExpression() ] "]" | "(" [ ParameterTypeList() ] ")" )*
}

void TypedefName() : {}
{
	<IDENTIFIER>
}



void LabeledStatement() : {}
{
	( <IDENTIFIER> ":" Statement() |
	  <CASE> ConstantExpression() ":" Statement() |
	  <DFLT> ":" Statement() )
}

void ExpressionStatement() : {}
{
	[ Expression() ] ";"
}


void CompoundStatement() : {}
{
	"{" 
	(
			(MSQL())*
			[ LOOKAHEAD(DeclarationList()) DeclarationList() ]
			[ StatementList() ]
	)
	"}"
}
void Statement() : {}
{
	( LOOKAHEAD(2)MSQL() |
	LOOKAHEAD(2)LabeledStatement() |
	  ExpressionStatement() |
	  CompoundStatement() |
	  SelectionStatement() |
	  IterationStatement() |
	  JumpStatement() )
}
void MSQL() : {}
{
    <SQL>"{"{System.out.println("Get some sql statements.");}
    (
		SQLDELTE() | SQLINSERT() | SQLSELECT() | SQLUPDATE()
	)+ 
	"}"
	";"
}

void SQLUPDATE():{}
{
	<UPDATE>{System.out.println("Get a UpdateStatement.");}
	<IDENTIFIER>
	<SET>
	<IDENTIFIER>
	"="
	(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
	(
		<WHERE>
		<IDENTIFIER>
		"="
		(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
		(
			(<AND> | <OR>)
			<IDENTIFIER>
			"="
			(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
		)*
	)*
	";"
}

void SQLINSERT():{}
{
	<INSERT>{System.out.println("Get a InsertStatement.");}
    <INTO>
    <IDENTIFIER>
	<VALUES>
	"("
	(
		(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
		(",")*
	)*
	")"
	";"
}

void SQLSELECT():{}
{
	<SELECT>{System.out.println("Get a QueryStatement.");}
	(
		"*" |
		(<IDENTIFIER>((",")*))*
	)
	<FROM>
	<IDENTIFIER>
	(
		<WHERE>
		<IDENTIFIER>
		"="
		(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
		(
			(<AND> | <OR>)
			<IDENTIFIER>
			"="
			(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
		)*
	)*
	";"
}
void SQLDELTE():{}
{
	<DELETE>{System.out.println("Get a DeleteStatement.");}
    <FROM>
    <IDENTIFIER>
	<WHERE>
	<IDENTIFIER>
    "="
	(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
	(
	(<AND>| <OR>)
	<IDENTIFIER>
	"="
	(<INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>)
	)*
	";"
}

void StatementList() : {}
{
	(Statement())+
}
void SelectionStatement() : {}
{
	( <IF> "(" Expression() ")" Statement() [ LOOKAHEAD(2) <ELSE> Statement() ] |
	  <SWITCH> "(" Expression() ")" Statement() )
}
void IterationStatement() : {}
{
	( <WHILE> "(" Expression() ")" Statement() |
	  <DO> Statement() <WHILE> "(" Expression() ")" ";" |
	  <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
}
void JumpStatement() : {}
{
	( <GOTO> <IDENTIFIER> ";" |
	  <CONTINUE> ";" |
	  <BREAK> ";" |
	  <RETURN> [ Expression() ] ";" )
}
void Expression() : {}
{
	AssignmentExpression() ( "," AssignmentExpression() )*
}
void AssignmentExpression() : {}
{
	  LOOKAHEAD(UnaryExpression() AssignmentOperator()) UnaryExpression() AssignmentOperator() AssignmentExpression() |
	  LOOKAHEAD(3) ConditionalExpression()
}
void AssignmentOperator() : {}
{
	( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
}
void ConditionalExpression() : {}
{
	LogicalORExpression() [ "?" Expression() ":" ConditionalExpression() ]
}
void ConstantExpression() : {}
{
	ConditionalExpression()
}
void LogicalORExpression() : {}
{
	LogicalANDExpression() [ "||" LogicalORExpression() ]
}
void LogicalANDExpression() : {}
{
	InclusiveORExpression() [ "&&" LogicalANDExpression() ]
}
void InclusiveORExpression() : {}
{
	ExclusiveORExpression() [ "|" InclusiveORExpression() ]
}
void ExclusiveORExpression() : {}
{
	ANDExpression() [ "^" ExclusiveORExpression() ]
}
void ANDExpression() : {}
{
	EqualityExpression() [ "&" ANDExpression() ]
}
void EqualityExpression() : {}
{
	RelationalExpression() [ ( "==" | "!=" ) EqualityExpression() ]
}
void RelationalExpression() : {}
{
	ShiftExpression() [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
}
void ShiftExpression() : {}
{
	AdditiveExpression() [ ( "<<" | ">>" ) ShiftExpression() ]
}
void AdditiveExpression() : {}
{
	MultiplicativeExpression() [ ( "+" | "-" ) AdditiveExpression() ]
}
void MultiplicativeExpression() : {}
{
	CastExpression() [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
}
void CastExpression() : {}
{
	( LOOKAHEAD("(" TypeName() ")" CastExpression() ) "(" TypeName() ")" CastExpression() |
	  UnaryExpression() )
}
void UnaryExpression() : {}
{
	( LOOKAHEAD(3) PostfixExpression() |
	  "++" UnaryExpression() |
	  "--" UnaryExpression() |
	  UnaryOperator() CastExpression() |
	  <SIZEOF> ( LOOKAHEAD(UnaryExpression() ) UnaryExpression() | "(" TypeName() ")" ) )
}
void UnaryOperator() : {}
{
	( "&" | "*" | "+" | "-" | "~" | "!" )
}
void PostfixExpression() : {}
{
	PrimaryExpression() ( "[" Expression() "]" |
	                      "(" [ LOOKAHEAD(ArgumentExpressionList() ) ArgumentExpressionList() ] ")" |
	  					  "." <IDENTIFIER> |
	  					  "->" <IDENTIFIER> |
	  					  "++" |
	  					  "--" )*
}
void PrimaryExpression() : {}
{
	( <IDENTIFIER> |
	  Constant() |
	  "(" Expression() ")" )
}
void ArgumentExpressionList() : {}
{
	AssignmentExpression() ( "," AssignmentExpression() )*
}
void Constant() : {} //常数
{
 <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL>
}
是周周不是粥粥
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌实践教学平台答案(Java实训作业答案)
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
03-24 3万+
搜集整理了一份最新最全的头歌（EduCoder）Java实训作业答案，分享给大家.(EduCoder)是信息技术类实践教学平台。(EduCoder)涵盖了计算机、大数据、云计算、人工智能、软件工程、物联网等专业课程。超60000个实训案例,建立学、练、评、测一体化实验环境。这份是头歌实践教学平台答案(Java实训作业答案)。 Java语言基础（一） - JAVA初体验 头歌实践教学平台答案(Java实训作业答案)第一关
educoder答案.rar
08-22
答案
使用javacc实现语法生成器（基于miniC语法）
did_you的博客
12-04 2032
/********* WRITEN BY ZZG *********/ /******** DATE: 12,4,2017 ********/ /** * JJTree template file created by SF JavaCC plugin 1.5.28+ wizard for JavaCC 1.5.0+ */ options { static = true; } PA
JavaCC实现语法分析
linovce的博客
12-27 2330
语义分析 设计MiniC的上下文无关文法，在“Parser.jjt”文件中表示该文法，生成调试递归下降分析程序，以便对任意输入的符号串进行分析； 以文件流的形式读入要分析的C语言程序； 如果输入的源程序符合MiniC的语法规范，在文件中输出语法树。 MiniC语法〈程序〉 → int main() {〈语句块〉* } 〈语句块〉 →〈语句〉| {〈语句块〉* } 〈语句〉 →〈顺序语句〉|〈条件
基于Minic的语法分析器（javacc）
12-30
基于Minic的语法分析器，javacc书写，实现了文件的读取和写入操作加压后可直接导入运行
[educoder] 编译原理 用JAVACC生成并扩充C语言的语法分析器（一）
weixin_45225566的博客
01-12 2279
第一关 熟悉JavaCC /* JavaCC 小测试 */ /* 功能：实现一个能够进行加法(+)，减法(-)，乘方(^)的计算器 */ /* 说明：在下面的begin和end之间添加代码，已经实现了简单的加法(+)，你需要完成剩下的部分，加油吧！ */ /* 提示： */ options { STATIC = false; } PARSER_BEGIN(Calc) import java.io.*; class Calc { public static void main(Strin
[educoder] 编译原理 用JAVACC生成并扩充C语言的语法分析器（二）
weixin_45225566的博客
01-12 1498
第2关 构建C语言的语法分析器 /* C grammar definition for use with JavaCC Contributed by Doug South ([email protected]) 21/3/97 This parser assumes that the C source file has been preprocessed : all #includes have been included and all macros have been ex
JavaCC语法分析器
only3g的专栏
07-20 1167
<br /> <br />JavaCC （Java Compiler Compiler）是Java实现的语法分析器，用以根据用户自定义规则进行上下文无关语法内容的分析工作，以简化编译器开发时编写涉及词法、语法、语义规则处理代码时的工程量。<br />较之C语言实现的简化编译构造程序LEX （Lexical Analyzers）和YACC （Yet Another Compiler Compiler），JavaCC使用递归下降的语法分析方法，定义的文法规则表达范围广泛。JavaCC不直接生成分析树或抽象
java写的c语言语法分析器_java实现C语言子集的语法分析器
weixin_30000735的博客
02-28 257
如题，只是做一个算法的演示，所以并不能识别C语言全部的关键字，像int 等关键字会被识别为标识符。可以按照自己需求自行扩充保留字表。程序功能：词法分析器从input文件中读入一小段C语言源程序，以二元式形式按顺序输出所有单词。输出结果在显示器上显示，同时存入output文件中。输入的C语言源程序中的所有标识符都要添加到标识符表id-list中，所有无符号整数都要添加到无符号整数表uint-list...
编译原理实验二语法分析java代码JavaCC
06-28
设计MiniC的上下文无关文法，利用JavaCC生成调试递归下降分析程序，以便对任意输入的符号串进行分析。本次实验的目的主要是加深对递归下降分析法的理解。 按照MiniC语言的语法规则检查词法分析输出的记号流是否符合这些规则，并根据这些规则所体现出的语言中的各种语法结构的层次性。把规则写入到JavaCC的 .jjt文件中，可以生成树状的层次结构。
javacc 语法分析代码
01-11
1. 掌握 JavaCC 语法分析器工作原理； 2. 设计 MiniC 的上下文无关文法，在“Parser.jjt”文件中表示该文法，生成调试递归下降分析程序，以便对任意输入的符号串进行分析； 3. 输出语法树。 4. 以文件流的形式读入要分析的 C 语言程序； 5. 如果输入的源程序符合 MiniC 的语法规范，输出语法树。
基于JavaCC的c语言编译器前端实现
09-23
基于JavaCC的c语言编译器前端实现代码，偶然翻出来的，上传到这里，给需要的朋友参考，献丑了。
Educoder头歌实践平台 Java 数据结构之图 答案.txt
11-10
Educoder头歌实践平台 中 Java 数据结构之图 共4关 金币共2300 的那个实践项目答案 由于图论问题渗透整个计算机科学，图算法对于计算机学科至关重要。成百上千的计算问题最后都可以归约为图论问题。
编译原理中用javacc实现MiniC的词法分析、语法分析、语义分析
02-23
用Javacc实现MiniC的词法分析、语法分析、语义分析。在词法分析部分根据单词的构词规则分类，输出<单词种别，单词自身值>二元式；在语法分析部分利用Javacc实现LL(1)文法，判断源语言是否符合MiniC的语法，如果不...
《编译原理》JAVACC实验三.zip
05-21
1. 掌握自顶向下语义分析中语义子程序的添加过程； 2. 掌握“拉链”、“回填”操作的原理及实现； 3. 根据MiniC的上下文无关文法，对赋值语句、算术表达式、关系表达式、if-else语句、while语句、布尔表达式等语法...
西农大编译原理实验二 语法分析器
04-23
按照MiniC语言的语法规则检查词法分析输出的记号流是否符合这些规则，并根据这些规则所体现出的语言中的各种语法结构的层次性。把规则写入到JavaCC的 .jjt文件中，可以生成树状的层次结构。
[educoder] 编译原理 用LEX(FLEX)生成PL语言的词法分析器
weixin_45225566的博客
01-12 2860
第1关 什么是lex/flex？ /* 简单词法分析器 */ /* 功能：能够识别出以小写字母ab结尾的所有字符串（仅含大小写字母）并给打印'Hit!' */ /* 说明：在下面的begin和end之间添加代码，已经实现了标识符和整常量的识别，你需要完成剩下的部分，加油吧！ */ /* 提示：你只需要保证合法的输入（以ab结尾的字符串）有结果，不合法的输入将会包含在.规则中～ */ %{ #include <stdio.h> %} %% /* begin */ [a-zA-Z]*ab
[educoder] 编译原理 用YACC(BISON)生成语法分析和翻译器
weixin_45225566的博客
01-12 1893
用Bison构建逆波兰计算器 /* 逆波兰符号计算器 */ /* 功能：能够计算出合法的后缀表达式的值，包括加法、减法、乘法、除法、乘方、取反等运算 */ /* 说明：在下面的begin和end之间添加代码，加油吧！ */ /* 提示： */ %{ #include <ctype.h> #include <stdio.h> #include <math.h> int yylex (void); void yyerror (char const
用javacc生成并扩充c语言的语法分析器
最新发布
06-28
使用JavaCC可以生成C语言的语法分析器，并且可以通过扩展JavaCC的语法规则来增强其功能。具体步骤如下： 1. 安装JavaCC工具，并配置环境变量。 2. 编写C语言的语法规则文件，以.jj为后缀名。 3. 使用JavaCC命令行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值