Anltr4的编写解释器

最新推荐文章于 2023-03-22 23:08:17 发布
最新推荐文章于 2023-03-22 23:08:17 发布
阅读量350 收藏
点赞数
分类专栏： JAVA Performance

Tiny在上周上线TinyUiEnterprise的http://www.tinygroup.org/组件，经过反馈测试发现模板引擎的性能一直有问题，请查看jprofile

 当然很多性能问题，我们正在完善中，诸如：非递归DFS、大对象生命周期、异步调用......

但是放在我面前的却是把原先ClassLoader加载后，进行调用执行的方式变更为使用anltr的解释性语言去执行。

通过一周左右的攻克，总算把最难啃的骨头给啃掉了，这离不开beetl的贡献，这里有些运用了其中核心代码，通过bytewrite的方式进行调用

本文不在过多论述anltr到底是什么玩意，我感觉这类文章在网上搜索一大堆，推荐去阅读http://blog.csdn.net/dc_726/article/details/45399371

核心代码

		}
        //语法分析
		BeetlLexer lexer = new BeetlLexer(input);
		lexer.removeErrorListeners();
		lexer.addErrorListener(syntaxError);

		//token就是语法树上节点，递归下降解析器
		CommonTokenStream tokens = new CommonTokenStream(lexer);
		//语法树
		BeetlParser parser = new BeetlParser(tokens);
		// 测试代码

		ProgContext tree = parser.prog();
		// begin parsing at init rule
		AntlrProgramBuilder pb = new AntlrProgramBuilder(gt);
		ProgramMetaData data = pb.build(tree);

 判断ASTNode的节点类型

if (node instanceof TinyTemplateParser.BlockContext) {
			TinyTemplateParser.BlockContext bc = (TinyTemplateParser.BlockContext) node;
			int count = bc.getChildCount();
			for (int i = 0; i < count; i++) {
				String str = bc.getChild(i).getText();
				int position = 0;
				if (!this.gt.getConf().directByteOutput) {
					StaticTextASTNode textNode = new StaticTextASTNode(
							position, null);
					return textNode;
				} else {
					StaticTextByteASTNode textNode = new StaticTextByteASTNode(
							position, null);
					return textNode;
				}
			}
			Statement block = parseBlock(bc.value(), node);
			return block;

		}

 本案例中采用最简单的模板，里面就是读取变量，没有用到自定义宏

那么如何不通过classloader，而是直接write出来呢？

ctx.byteWriter.write((char[]) ctx.staticTextArray[textIndex]);

 

  /*
  注意：此文档初始版本来自jetbrick-template，后经过修改成为Tiny模板引擎词法文件
  * jetbrick-template
  * http://subchen.github.io/jetbrick-template/
  *
  * Copyright 2010-2013 Guoqiang Chen. All rights reserved.
  * Email: subchen@gmail.com
  */
lexer grammar TinyTemplateLexer;
/*
@header {
package jetbrick.template.parser.grammer;
}
*/
// *******************************************************************
// ------- DEFAULT mode for Plain Text -------------------------------
COMMENT_LINE           : '##' ~[\r\n]* NEWLINE          ;
COMMENT_BLOCK2            : '#*' .*? '*#'                 ;
COMMENT_BLOCK1            : '#--' .*? '--#'                  ;
fragment NEWLINE        : ('\r'? '\n' | EOF)              ;

TEXT_PLAIN              : ~('$'|'#'|'\\')+                ;
TEXT_CDATA              : '#[[' .*? ']]#'                 ;
TEXT_ESCAPED_CHAR       : ('\\#'|'\\$'|'\\\\')            ;
TEXT_SINGLE_CHAR        : ('#'|'$'|'\\')                  ;
PARA_SPLITER           :[ \t]* (',')?[ \t]*    ;
I18N_OPEN              : '$${'                            -> pushMode(INSIDE) ;

//VALUE_COMPACT_OPEN              : '$'                    ;
VALUE_OPEN              : '${'                            -> pushMode(INSIDE) ;
VALUE_ESCAPED_OPEN      : '$!{'                           -> pushMode(INSIDE) ;

DIRECTIVE_OPEN_SET      : ('#set'|'#!set' )     ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_IF       : '#if'       ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_ELSEIF   : '#elseif'   ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_FOR      : ('#for'|'#foreach')      ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_BREAK    : '#break'    ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_CONTINUE : '#continue' ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_STOP     : '#stop'     ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_INCLUDE  : '#include'  ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_CALL  : '#call'  ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_CALL  : '#@call'  ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_LAYOUT_IMPL  : '#@layout'  ARGUMENT_START      -> pushMode(INSIDE) ;

DIRECTIVE_OPEN_MACRO    : '#macro'    [ \t]+ ID ARGUMENT_START -> pushMode(INSIDE) ;

DIRECTIVE_OPEN_LAYOUT   : '#layout' ARGUMENT_START -> pushMode(INSIDE) ;

fragment ID             : [_a-zA-Z$][_a-zA-Z$0-9]*        ;
fragment ARGUMENT_START : [ \t]* '('                      ;

DIRECTIVE_SET           : '#set'|'#!set'                          ;
DIRECTIVE_IF            : '#if'                           ;
DIRECTIVE_ELSEIF        : '#elseif'                       ;
DIRECTIVE_FOR           : '#for'                          ;
DIRECTIVE_INCLUDE       : '#include'                      ;
DIRECTIVE_BREAK         : '#break'                        ;
DIRECTIVE_CONTINUE      : '#continue'                     ;
DIRECTIVE_STOP          : '#stop'                         ;
DIRECTIVE_MACRO         : '#macro'                        ;

DIRECTIVE_ELSE          : '#else'|'#{else}'                   ;
DIRECTIVE_END           : '#end'|'#{end}'                 ;
DIRECTIVE_BLANK         : '#b'|'#{b}'                       ;
DIRECTIVE_END_OF_LINE           : '#eol'|'#{eol}'                 ;
DIRECTIVE_TABS           : '#t'|'#{t}'                 ;
DIRECTIVE_TABS_INDENT           : '#]'|'#{]}'                 ;
DIRECTIVE_TABS_DENT           : '#['|'#{[}'                 ;
DIRECTIVE_BODYCONTENT  : '#bodyContent'|'#{bodyContent}' ;
DIRECTIVE_IMPORT  : '#import' ARGUMENT_START      -> pushMode(INSIDE) ;

//DIRECTIVE_CALL    : '#' ID      ;
DIRECTIVE_MACRO_INVOKE    : '#' ID     ARGUMENT_START      -> pushMode(INSIDE) ;
DIRECTIVE_OPEN_MACRO_INVOKE    : '#@' ID    ARGUMENT_START -> pushMode(INSIDE) ;

// It is a text which like a directive.
// It must be put after directive defination to avoid confliction.
TEXT_DIRECTIVE_LIKE     : '#' [a-zA-Z0-9]+                ;


// *******************************************************************
// -------- INSIDE mode for directive --------------------------------
mode INSIDE;

WHITESPACE              : [ \t\r\n]+                       -> skip ;

LEFT_PARENTHESE         : '('                              -> pushMode(INSIDE) ;
RIGHT_PARENTHESE        : ')'                              -> popMode ;
LEFT_BRACKET            : '['                              ;
RIGHT_BRACKET           : ']'                              ;
LEFT_BRACE              : '{'                              -> pushMode(INSIDE) ;
RIGHT_BRACE             : '}'                              -> popMode ;
IN                       : 'in'                             ;
OP_ASSIGNMENT           : '='                              ;

OP_DOT_DOT              :  '..'                              ;
OP_DOT_INVOCATION       : '.'                              ;
OP_DOT_INVOCATION_SAFE  : '?.'                             ;

OP_EQUALITY_EQ          : '=='                             ;
OP_EQUALITY_NE          : '!='                             ;

OP_RELATIONAL_GT        : '>'                              ;
OP_RELATIONAL_LT        : '<'                              ;
OP_RELATIONAL_GE        : '>='                             ;
OP_RELATIONAL_LE        : '<='                             ;

OP_CONDITIONAL_AND      : '&&'                             ;
OP_CONDITIONAL_OR       : '||'                             ;
OP_CONDITIONAL_NOT      : '!'                              ;

OP_MATH_PLUS            : '+'                              ;
OP_MATH_MINUS           : '-'                              ;
OP_MATH_MULTIPLICATION  : '*'                              ;
OP_MATH_DIVISION        : '/'                              ;
OP_MATH_REMAINDER       : '%'                              ;
OP_MATH_INCREMENT       : '++'                             ;
OP_MATH_DECREMENT       : '--'                             ;

OP_BITWISE_AND          : '&'                              ;
OP_BITWISE_OR           : '|'                              ;
OP_BITWISE_NOT          : '~'                              ;
OP_BITWISE_XOR          : '^'                              ;
OP_BITWISE_SHL          : '<<'                             ;

OP_BITWISE_SHR        : '>>'                             ;
OP_BITWISE_SHR_2      : '>>>'                            ;

OP_CONDITIONAL_TERNARY  : '?'                              ;

OP_SIMPLE_CONDITION_TERNARY      : '?:'                           ;

COMMA                   : ','                              ;
COLON                   : ':'                              ;
AT                      : '@'                              ;

KEYWORD_TRUE            : 'true'                           ;
KEYWORD_FALSE           : 'false'                          ;
KEYWORD_NULL            : 'null'                           ;


IDENTIFIER              : [_a-zA-Z][_a-zA-Z0-9]*         ;

INTEGER                 : INT [lLfFdD]?                    ;
INTEGER_HEX             : '0x' HEX+ [lL]?                  ;
FLOATING_POINT          : INT ('.' FRAC)? EXP? [fFdD]?     ;
fragment INT            : '0' | [1-9] [0-9]*               ;
fragment FRAC           : [0-9]+                           ;
fragment EXP            : [Ee] [+\-]? INT                  ;

STRING_DOUBLE           : '"'  (ESC|.)*? '"'               ;
STRING_SINGLE           : '\'' (ESC|.)*? '\''              ;
fragment ESC            : '\\' ([btnfr"'\\]|UNICODE)       ;
fragment UNICODE        : 'u' HEX HEX HEX HEX              ;
fragment HEX            : [0-9a-fA-F]                      ;

 

 

 /*
 注意：此文档初始版本来自jetbrick-template，后经过修改成为Tiny模板引擎语法文件
 * jetbrick-template
 * http://subchen.github.io/jetbrick-template/
 *
 * Copyright 2010-2013 Guoqiang Chen. All rights reserved.
 * Email: subchen@gmail.com
 */
parser grammar TinyTemplateParser;

options {
    tokenVocab = TinyTemplateLexer; // use tokens from JetTemplateLexer.g4
}

/*
@header {
package jetbrick.template.parser.grammer;
}
*/

// -------- rule ---------------------------------------
template    :   block
            ;

block       :   (comment | directive | text | value)*
            ;


text        :   TEXT_PLAIN
            |   TEXT_CDATA
            |   TEXT_SINGLE_CHAR
            |    COMMENT_LINE
            |   COMMENT_BLOCK1
            |   COMMENT_BLOCK2
            |   TEXT_ESCAPED_CHAR
            |   TEXT_DIRECTIVE_LIKE
            ;
comment        :     COMMENT_LINE
            |   COMMENT_BLOCK1
            |   COMMENT_BLOCK2
            ;
value       :   //VALUE_COMPACT_OPEN  identify_list
               VALUE_OPEN         expression '}'
            |   VALUE_ESCAPED_OPEN expression '}'
            |  I18N_OPEN  identify_list '}'
            ;


directive   :   set_directive
            |   if_directive
            |   for_directive
            |   break_directive
            |   import_directive
            |   continue_directive
            |   stop_directive
            |   include_directive
            |   macro_directive
            |   call_block_directive
            |   layout_directive
            |   layout_impl_directive
            |   call_directive
            |   endofline_directive
            |   blank_directive
            |   tabs_directive
            |   indent_directive
            |   dent_directive
            |   call_macro_directive
            |   call_macro_block_directive
            |   bodycontent_directive
            |   invalid_directive
            ;
identify_list
            :IDENTIFIER ('.' IDENTIFIER)*
            ;

define_expression_list
            :   define_expression (','? define_expression)*
            ;
para_expression_list
            :   para_expression (','? para_expression)*
            ;
para_expression
            :   IDENTIFIER '=' expression
            |   expression
            ;

define_expression
            :   IDENTIFIER ('=' expression)?
            ;

set_directive
            :   DIRECTIVE_OPEN_SET set_expression (','? set_expression)* ')'
            ;
set_expression
            :    IDENTIFIER '=' expression
            ;
endofline_directive
            :    DIRECTIVE_END_OF_LINE
            ;
tabs_directive
            :    DIRECTIVE_TABS
            ;
blank_directive
            :    DIRECTIVE_BLANK
            ;
indent_directive
            :    DIRECTIVE_TABS_INDENT
            ;
dent_directive
            :    DIRECTIVE_TABS_DENT
            ;

if_directive
            :   DIRECTIVE_OPEN_IF expression ')' block elseif_directive* else_directive? DIRECTIVE_END
            ;
elseif_directive
            :   DIRECTIVE_OPEN_ELSEIF expression ')' block
            ;
else_directive
            :   DIRECTIVE_ELSE block
            ;

for_directive
            :   DIRECTIVE_OPEN_FOR for_expression ')' block else_directive? DIRECTIVE_END
            ;
for_expression
            :    IDENTIFIER (':'|'in') expression
            ;

break_directive
            :   DIRECTIVE_OPEN_BREAK expression?')'
            |   DIRECTIVE_BREAK
            ;
import_directive
            :   DIRECTIVE_IMPORT expression ')'
            ;

continue_directive
            :   DIRECTIVE_OPEN_CONTINUE expression? ')'
            |   DIRECTIVE_CONTINUE
            ;
stop_directive
            :   DIRECTIVE_OPEN_STOP expression? ')'
            |   DIRECTIVE_STOP
            ;

include_directive
            :   DIRECTIVE_OPEN_INCLUDE expression (','? '{' hash_map_entry_list? '}')? ')'
            ;


macro_directive
            :   DIRECTIVE_OPEN_MACRO define_expression_list? ')' block DIRECTIVE_END
            ;

layout_directive
            :   DIRECTIVE_OPEN_LAYOUT IDENTIFIER ')' block DIRECTIVE_END
            ;

call_block_directive
            :   DIRECTIVE_OPEN_CALL  expression (','?  para_expression_list )? ')' block DIRECTIVE_END
            ;
layout_impl_directive
            :   DIRECTIVE_OPEN_LAYOUT_IMPL IDENTIFIER ')' block DIRECTIVE_END
            ;

call_directive
            :   DIRECTIVE_CALL  expression ( ','? para_expression_list )? ')'
            ;

call_macro_block_directive
            :  DIRECTIVE_OPEN_MACRO_INVOKE   para_expression_list? ')' block DIRECTIVE_END
            ;

bodycontent_directive
            :DIRECTIVE_BODYCONTENT
            ;
call_macro_directive
            :  DIRECTIVE_MACRO_INVOKE   para_expression_list? ')'
            ;
invalid_directive
            :   DIRECTIVE_SET
//            |   DIRECTIVE_PUT
            |   DIRECTIVE_IF
            |   DIRECTIVE_ELSEIF
            |   DIRECTIVE_FOR
            |   DIRECTIVE_INCLUDE
//            |   DIRECTIVE_OPEN_CALL_MACRO
//            |   DIRECTIVE_BODY_CALL
            |   DIRECTIVE_MACRO
            ;

expression  :   '(' expression ')'                                           # expr_group
            |   constant                                                     # expr_constant
            |   IDENTIFIER                                                   # expr_identifier
            |   '[' (expression_list |expression_range)?  ']'       # expr_array_list
            |   '{' hash_map_entry_list? '}'                                 # expr_hash_map
            |   expression ('.'|'?.') IDENTIFIER '(' expression_list? ')'    # expr_member_function_call
            |   expression ('.'|'?.') IDENTIFIER                             # expr_field_access
            |   IDENTIFIER '(' expression_list? ')'                          # expr_function_call

            |   expression ('?')? '[' expression ']'                         # expr_array_get
            |   expression ('++'|'--')                                       # expr_single_right
            |   ('+' <assoc=right> |'-' <assoc=right>)  expression           # expr_math_unary_prefix
            |   ('++'|'--')       expression                                 # expr_single_left
            |   '~' <assoc=right> expression                                 # expr_math_unary_prefix
            |   '!' <assoc=right> expression                                 # expr_math_unary_prefix
            |   expression ('*'|'/'|'%')  expression                         # expr_math_binary_basic
            |   expression ('+'|'-')      expression                         # expr_math_binary_basic
            |   expression ('<<'|'>>'|'>>>') expression             # expr_math_binary_shift
            |   expression ('>='|'<='|'>'|'<') expression                    # expr_compare_relational
            |   expression ('=='|'!=') expression                            # expr_compare_equality
            |   expression '&'  expression                                   # expr_math_binary_bitwise
            |   expression '^' <assoc=right> expression                      # expr_math_binary_bitwise
            |   expression '|'  expression                                   # expr_math_binary_bitwise
            |   expression '&&' expression                                   # expr_compare_condition
            |   expression '||' expression                                   # expr_compare_condition
            |   expression '?' <assoc=right> expression ':' expression       # expr_conditional_ternary
            |   expression '?:' expression       # expr_simple_condition_ternary
            ;

constant    :   STRING_DOUBLE
            |   STRING_SINGLE
            |   INTEGER
            |   INTEGER_HEX
            |   FLOATING_POINT
            |   KEYWORD_TRUE
            |   KEYWORD_FALSE
            |   KEYWORD_NULL
            ;

expression_list
            :   expression (',' expression)*
            ;

hash_map_entry_list
            :   expression ':' expression (',' expression ':' expression)*
            ;

expression_range
            :   expression '..' expression
            ;

 

cywhoyi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ANTLR4(四) 基础设计语法
pourtheworld的博客
08-30 7093
ANTLR4基础设计语法写在之前语言模式序列选择词法符号依赖嵌套处理优先级、结合性、左递归优先级结合性左递归核心语法标记总结词法结构匹配标识符匹配数字匹配字符串常量匹配注释和空格核心词法规则总结 写在之前 对于ANTLR的.g4文件来说，它的格式一般如下： //xx.g4 grammar xx 文法1： 文法2： 文法... 词法规则 词法1： 词法2： ... 注意的几点： 文件名和grammar关键字后跟的语法名应该一致。 文法规则和词法规则可以同时存在一个文件中，但文法以小写开头，词法以大写
antlr4 简单实用入门——(一)
诸葛子房的博客
12-28 1万+
Antlr4 简介 简介 Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来
Antlr4入门（安装、配置、简单实例）
热门推荐
qq_41957824的博客
05-29 1万+
Antlr4安装、配置、简单实例 2020.5.28 仅本人初次使用Antlr4的经历分享 目前所知有3种使用Antlr4的方式： 通过命令行使用； 在Eclipse中安装Antlr4插件；（个人不推荐，原因：antlr4插件下载也有许多问题） 在Intellij IDEA中安装Antlr4插件。 本文仅分享第一种方式。 什么是Antlr4？ ​ Antlr4 (ANother Tool for Language Recognition)， 是一个强大的跨语言语法解析器，可以用来读取、处理、执行或
Antlr4 JAVA 语法解析器
01-06
解析java语法 grammar Java; // starting point for parsing a java file compilationUnit : packageDeclaration? importDeclaration* typeDeclaration* EOF ; packageDeclaration : annotation* 'package' qualifiedName ';' ; importDeclaration : 'import' 'static'? qualifiedName ('.' '*')? ';' ; typeDeclaration : classOrInterfaceModifier* classDeclaration | classOrInterfaceModifier* enumDeclaration | classOrInterfaceModifier* interfaceDeclaration | classOrInterfaceModifier* annotationTypeDeclaration | ';' ; .....
Antlr4入门（三）如何编写语法文件
qq_37771475的博客
06-04 1万+
本章我们将会学习词法及语法规则，以及四种抽象的计算机语言模式。因为ANTLR的语法规则跟正则表达式是很类似的，所以还是推荐先阅读下正则表达式的相关内容，这样在编写语法文件时可以事半功倍。 一、四种语言模式 虽然在过去的50年里人们发明了许许多多的编程语言，但是，相对而言，基本的语言模式种类并不多。之所以如此，是因为人们在设计编程语言的时候，倾向于将它们设计成与脑海中的自然语言相类似。我们希望符号按照有效的顺序排列，并且符号之间拥有着特定的依赖关系。举个例子，{(}) 就是不符合语法的，因为符号的顺序.
antlr4rust:用于Rust编程语言的ANTLR4解析器生成器运行时
05-01
ANTLR4工具（解析器生成器） 生成器部件当前位于我的antlr4叉rust-target分支中。此存储库中的版已自动构建为最新版本。 因此，如果您只想生成解析器，或者只想对运行时部分做出贡献，则不必自己构建它。 但是，如果...
anltr学习资料
12-12
ANTLR生成的解析器是用Java编写的，但支持多种目标语言，包括C#、Python、JavaScript等。 ANTLR的核心功能在于它能生成LL(*)和LR解析器，这些解析器可以处理上下文敏感的语法，使得ANTLR在解析复杂的语言时表现出色...
Oracle SQL语法ANLTR
06-05
Grammar for Oracle's SELECT statement for ANTLR v3, target C language
intellij-plugin-v4:ANTLR v4的IntelliJ插件
05-13
ANTLR v4的IntelliJ Idea插件 适用于ANTLR v4的 2017.1 .. 2020.3插件（ ）。该插件适用于ANTLR v4语法，包括ANTLR 4.9.1。 与IntelliJ IDEA和其他基于IntelliJ的IDE... 处理单独的解析器和讲座，如TParser.g4和TLexer
Antlr入门详细教程
07-17
Antlr 中有主要类有两种（其实还有一种 TreeLexer ） 　　 　　Lexer： 文法分析器类。主要用于把读入的字节流根据规则分段。既把长面条根据你要的尺寸切成一段一段：）并不对其作任何修改。 　　 　　Parser： 解析器类。主要用于处理经过 Lexer 处理后的各段。一些具体的操作都在这里。
使用antlr4实现的CMM语言解释器
12-13
实现的有瑕疵，望周知，上传资源赚点积分，希望你们独立完成。
anltr简易计算器
06-12
编译原理课程设计简易计算器 anltr生成的java类 实现多种功能
30分钟入门DSL工具Antlr4——概念、案例
简单就好
03-07 9246
本文主要面向初学者介绍Antlr4，一款常用语词法语法解析器生成的第三方工具包。全文主要回答几个问题： 1、antlr的是什么？ 2、antlr的功能有哪些，如何使用？ 3、在公司中使用antlr案例？ 不知道各位是如何关注到antlr，笔者是因为硕士阶段与中兴合作的一个项目中需要写SQL解析器才渐渐了解到它。后来发现它在大数据中非常实用，尤其在SQL方面。Terence Parr的The Defi
Antlr v4入门教程和实践
yixianshijie的博客
11-23 4550
一.ANTRL 是什么 当我们实现一种语言时，我们需要构建读取句子（sentence）的应用，并对输入中的元素做出反应。如果应用计算或执行句子，我们就叫它解释器（interpreter），包括计算器、配置文件读取器、Python解释器都属于解释器。如果我们将句子转换成另一种语言，我们就叫它翻译器（translator），像Java到C#的翻译器和编译器都属于翻译器。不管是解释器还是翻译器，应用首先都要识别出所有有效的句子、词组、字词组等，识别语言的程序就叫解析器（parser）或语法分析器（syntax
Anltr
weixin_34163741的博客
04-02 79
http://hi.baidu.com/%BD%F1%C9%FA%C1%B5%C2%B6/blog/item/8cee8e1e98251b8487d6b614.html http://wenku.baidu.com/view/aad28a29cfc789eb172dc8d0.html http://www.ibm.com/developerworks/cn/java/j-lo-antlr/
antlr4 介绍
d64793946的博客
09-26 2504
一.语法说明: 一般我们解析语言分为,词法解析和语法解析 词法解析根据用户输入生成一系列token序列（即关键字,操作数，操作方法等的列表） 语法解析根据token生成语法树(这里就是根据编写的g4 文件生成对应的树状结构及树状结构的值) 二.g4说明 1.antlr4 分为词法规则和文法规则 文法(语法)规则一般对应非叶子节点（文法规则有小写字母组成） 词法一般对应叶子节点（...
ANTLR4入门【打造你自己的语法规则】
qq_33129875的博客
03-22 7511
antlr4学习，结合idea使用，java代码实现一个带括号的四则运算规则
Antlr4介绍和Helloworld
离离原上草，一岁一枯荣，野火烧不尽，春风吹又生。
04-09 2125
摘要：本文将首先介绍Antlr4，以及如何通过Antlr4 grammer生成对应的hello的AST 1. Antlr4简单介绍 Antlr4（Another Tool for Language Recognition）是一款基于Java开发的开源的语法分析器生成工具，能够根据语法规则文件生成对应的语法分析器，广泛应用于DSL构建，语言词法语法解析等领域。现在在非常多的流行的框架中都用使用，例如，在构建特定语言的AST方面，CheckStyle工具，就是基于Antlr来解析Java的语法结构的（当前Jav
Anltr4编译c#转java
最新发布
05-19
ANTLR4是一种语法分析器生成器，可以用于许多编程语言。如果您想使用ANTLR4将C#代码转换为Java代码，您需要执行以下步骤： 1. 安装ANTLR4：您可以从ANTLR4的官方网站（https://www.antlr.org/）下载ANTLR4，并按照安装说明进行安装。 2. 创建C#语法：首先，您需要创建一个C#语法文件。您可以使用ANTLR4的ANTLRWorks或ANTLR4插件来创建该文件。 3. 生成ANTLR4解析器：使用ANTLR4生成器，您需要生成C#的解析器和词法分析器。 4. 创建Java语法：接下来，您需要创建Java语法文件。您可以使用ANTLRWorks或ANTLR4插件来创建该文件。 5. 生成Java解析器：最后，使用ANTLR4生成器生成Java的解析器和词法分析器。 请注意，ANTLR4仅处理语法分析，因此您可能需要执行其他步骤来将C#代码转换为Java代码。这可能包括语义分析、代码生成等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值