想开发一个自己的Java编译器,生成机器代码的Java编译器

[HashCodeWithJava]

我是个编译原理和编译技术的狂热爱好者.
接触了Java不久，可是一直被Java的速度困扰。
希望能开发出和C/C++一样高效的Java编译器.

[xyzxyz1111]

只要目前的计算机体系结构还是冯式,就是不可能的

[fantasyCoder]

楼主！！！
我强烈支持你

//但是从理论上讲，java的执行速度永远也比不上c/c++（只要目前的计算机体系结构还是冯式）
引用楼上的！
除非你不考虑跨平台！
这也失去了java的最
大优势！

[HashCodeWithJava]

对啊。
丢弃Java的跨平台性能和(甚至是自动垃圾回收这些性能)

[weidl]

请问：做个编译器，除了需要编译原理的知识之外，还需要什么技术？
谢拉

[rainight]

联系到网络速度，数据库执行速度等实际环境，java的所谓慢这一相对特性根本不是制约java作为企业级应用的瓶颈。

[HashCodeWithJava]

公布Java的词法文件和语法文件!
%{
/**************************************************************/
/* This file contains a restricted lexer for java language. */
/* The lexer will scan java programs in ASCII without unicode */
/* characters and/or unicode escape sequences. */
/* It is provided only to enable the grammar user to test it */
/* right away. */
/**************************************************************/
#include <YTAB.H>
%}

Separator [\(\)\{\}\[\]\;\,\.]
Delimiter1 [\=\>\<\!\~\?\:\+\-\*\/\&\|\^\%]
HexDigit [0-9a-fA-F]
Digit [0-9]
OctalDigit [0-7]
TetraDigit [0-3]
NonZeroDigit [1-9]
Letter [a-zA-Z_]
AnyButSlash [^\/]
AnyButAstr [^\*]
BLK [\b]
TAB [\t]
FF [\f]
ESCCHR [\\]
CR [\r]
LF [\n]

Escape [\\]([r]|[n]|[b]|[f]|[t]|[\\])
Identifier {Letter}({Letter}|{Digit})*

Comment1 [\/][\*]({AnyButAstr}|[\*]{AnyButSlash})*[\*][\/]
Comment2 [\/][\/].*
Comment ({Comment1}|{Comment2})
WhiteSpace ({CR}|{LF}|{FF}|{TAB}|{BLK}|[ ])

Dimension [\[]({WhiteSpace}|{Comment})*[\]]

IntSuffix ([l]|[L])
DecimalNum {NonZeroDigit}{Digit}*{IntSuffix}?
OctalNum [0]{OctalDigit}*{IntSuffix}?
HexNum [0]([x]|[X]){HexDigit}{HexDigit}*{IntSuffix}?
IntegerLiteral ({DecimalNum}|{OctalNum}|{HexNum})

Sign ([\+]|[\-])
FlSuffix ([f]|[F]|[d][D])
SignedInt {Sign}?{Digit}+
Expo ([e]|[E])
ExponentPart {Expo}{SignedInt}?
Float1 {Digit}+[\.]{Digit}+?{ExponentPart}?{FlSuffix}?
Float2 [\.]{Digit}+{ExponentPart}?{FlSuffix}?
Float3 {Digit}+{ExponentPart}{FlSuffix}?
Float4 {Digit}+{FlSuffix}
FloatingPoint ({Float1}|{Float2}|{Float3}|{Float4})

AnyChrChr [^\\']
AnyStrChr [^\\"]
Character [\']({Escape}|{AnyChrChr})[\']
String [\"]({Escape}|{AnyStrChr})*[\"]
Numeric ({IntegerLiteral}|{FloatingPoint})
Literal ({Numeric}|{Character}|{String})



%%

"true" {return LITERAL;}
"false" {return LITERAL;}

{Separator} {return yytext[0];}
{Delimiter1} {return yytext[0];}
{Dimension} {return OP_DIM;}

"==" {return OP_EQ;}
"<=" {return OP_LE;}
">=" {return OP_GE;}
"!=" {return OP_NE;}
"||" {return OP_LOR;}
"&&" {return OP_LAND;}
"++" {return OP_INC;}
"--" {return OP_DEC;}
">>" {return OP_SHR;}
"<<" {return OP_SHL;}
">>>" {return OP_SHRR;}
"+=" {return ASS_ADD;}
"-=" {return ASS_SUB;}
"*=" {return ASS_MUL;}
"/=" {return ASS_DIV;}
"&=" {return ASS_AND;}
"|=" {return ASS_OR;}
"^=" {return ASS_XOR;}
"%=" {return ASS_MOD;}
"<<=" {return ASS_SHL;}
">>=" {return ASS_SHR;}
">>>=" {return ASS_SHRR;}

"abstract" {return ABSTRACT;}
"do" {return DO;}
"implements" {return IMPLEMENTS;}
"package" {return PACKAGE;}
"throw" {return THROW;}
"boolean" {return BOOLEAN;}
"double" {return DOUBLE;}
"import" {return IMPORT;}
"private" {return PRIVATE;}
"throws" {return THROWS;}
"break" {return BREAK;}
"else" {return ELSE;}
"inner" {return INNER;}
"protected" {return PROTECTED;}
"transient" {return TRANSIENT;}
"byte" {return BYTE;}
"extends" {return EXTENDS;}
"instanceof" {return INSTANCEOF;}
"public" {return PUBLIC;}
"try" {return TRY;}
"case" {return CASE;}
"final" {return FINAL;}
"int" {return INT;}
"rest" {return REST;}
"var" {return VAR;}
"cast" {return CAST;}
"finally" {return FINALLY;}
"interface" {return INTERFACE;}
"return" {return RETURN;}
"void" {return VOID;}
"catch" {return CATCH;}
"float" {return FLOAT;}
"long" {return LONG;}
"short" {return SHORT;}
"volatile" {return VOLATILE;}
"char" {return CHAR;}
"for" {return FOR;}
"native" {return NATIVE;}
"static" {return STATIC;}
"while" {return WHILE;}
"class" {return CLASS;}
"future" {return FUTURE;}
"new" {return NEW;}
"super" {return SUPER;}
"const" {return CONST;}
"generic" {return GENERIC;}
"null" {return NULL;}
"switch" {return SWITCH;}
"continue" {return CONTINUE;}
"goto" {return GOTO;}
"operator" {return OPERATOR;}
"synchronized" {return SYNCHRONIZED;}
"default" {return DEFAULT;}
"if" {return IF;}
"outer" {return OUTER;}
"this" {return THIS;}

{Identifier} {return IDENTIFIER;}

{Literal} {return LITERAL;}

{WhiteSpace} {}

{Comment} {}

[HashCodeWithJava]

Java语法文件1
%{
/*------------------------------------------------------------------
* Copyright (C) 1996, 1997 Dmitri Bronnikov, All rights reserved.
*
* THIS GRAMMAR IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGMENT.
*
* [e-mail]
*
*------------------------------------------------------------------
*
* VERSION 1.03 DATE 11 NOV 1997
*
*------------------------------------------------------------------
*
* UPDATES
*
* 1.03 Added Java 1.1 changes:
* inner classes,
* anonymous classes,
* non-static initializer blocks,
* array initialization by new operator
* 1.02 Corrected cast expression syntax
* 1.01 All shift/reduce conflicts, except dangling else, resolved
*
*------------------------------------------------------------------
*
* PARSING CONFLICTS RESOLVED
*
* Some Shift/Reduce conflicts have been resolved at the expense of
* the grammar defines a superset of the language. The following
* actions have to be performed to complete program syntax checking:
*
* 1) Check that modifiers applied to a class, interface, field,
* or constructor are allowed in respectively a class, inteface,
* field or constructor declaration. For example, a class
* declaration should not allow other modifiers than abstract,
* final and public.
*
* 2) For an expression statement, check it is either increment, or
* decrement, or assignment expression.
*
* 3) Check that type expression in a cast operator indicates a type.
* Some of the compilers that I have tested will allow simultaneous
* use of identically named type and variable in the same scope
* depending on context.
*
* 4) Change lexical definition to change '[' optionally followed by
* any number of white-space characters immediately followed by ']'
* to OP_DIM token. I defined this token as [\[]{white_space}*[\]]
* in the lexer.
*
*------------------------------------------------------------------
*
* UNRESOLVED SHIFT/REDUCE CONFLICTS
*
* Dangling else in if-then-else
*
*------------------------------------------------------------------
*/
%}

%token ABSTRACT
%token BOOLEAN BREAK BYTE BYVALUE
%token CASE CAST CATCH CHAR CLASS CONST CONTINUE
%token DEFAULT DO DOUBLE
%token ELSE EXTENDS
%token FINAL FINALLY FLOAT FOR FUTURE
%token GENERIC GOTO
%token IF IMPLEMENTS IMPORT INNER INSTANCEOF INT INTERFACE
%token LONG
%token NATIVE NEW JNULL
%token OPERATOR OUTER
%token PACKAGE PRIVATE PROTECTED PUBLIC
%token REST RETURN
%token SHORT STATIC SUPER SWITCH SYNCHRONIZED
%token THIS THROW THROWS TRANSIENT TRY
%token VAR VOID VOLATILE
%token WHILE
%token OP_INC OP_DEC
%token OP_SHL OP_SHR OP_SHRR
%token OP_GE OP_LE OP_EQ OP_NE
%token OP_LAND OP_LOR
%token OP_DIM
%token ASS_MUL ASS_DIV ASS_MOD ASS_ADD ASS_SUB
%token ASS_SHL ASS_SHR ASS_SHRR ASS_AND ASS_XOR ASS_OR
%token IDENTIFIER LITERAL BOOLLIT

%start CompilationUnit

%%

TypeSpecifier
: TypeName
| TypeName Dims
;

TypeName
: PrimitiveType
| QualifiedName
;

ClassNameList
: QualifiedName
| ClassNameList ',' QualifiedName
;

PrimitiveType
: BOOLEAN
| CHAR
| BYTE
| SHORT
| INT
| LONG
| FLOAT
| DOUBLE
| VOID
;

CompilationUnit
: ProgramFile
;

ProgramFile
: PackageStatement ImportStatements TypeDeclarations
| PackageStatement ImportStatements
| PackageStatement TypeDeclarations
| ImportStatements TypeDeclarations
| PackageStatement
| ImportStatements
| TypeDeclarations
;

PackageStatement
: PACKAGE QualifiedName ';'
;

TypeDeclarations
: TypeDeclaration
| TypeDeclarations TypeDeclaration
;

ImportStatements
: ImportStatement
| ImportStatements ImportStatement
;

ImportStatement
: IMPORT QualifiedName ';'
| IMPORT QualifiedName '.' '*' ';'
;

QualifiedName
: IDENTIFIER
| QualifiedName '.' IDENTIFIER
;

TypeDeclaration
: ClassHeader '{' FieldDeclarations '}'
| ClassHeader '{' '}'
;

ClassHeader
: Modifiers ClassWord IDENTIFIER Extends Interfaces
| Modifiers ClassWord IDENTIFIER Extends
| Modifiers ClassWord IDENTIFIER Interfaces
| ClassWord IDENTIFIER Extends Interfaces
| Modifiers ClassWord IDENTIFIER
| ClassWord IDENTIFIER Extends
| ClassWord IDENTIFIER Interfaces
| ClassWord IDENTIFIER
;

Modifiers
: Modifier
| Modifiers Modifier
;

Modifier
: ABSTRACT
| FINAL
| PUBLIC
| PROTECTED
| PRIVATE
| STATIC
| TRANSIENT
| VOLATILE
| NATIVE
| SYNCHRONIZED
;

ClassWord
: CLASS
| INTERFACE
;

Interfaces
: IMPLEMENTS ClassNameList
;

FieldDeclarations
: FieldDeclaration
| FieldDeclarations FieldDeclaration
;

FieldDeclaration
: FieldVariableDeclaration ';'
| MethodDeclaration
| ConstructorDeclaration
| StaticInitializer
| NonStaticInitializer
| TypeDeclaration
;

FieldVariableDeclaration
: Modifiers TypeSpecifier VariableDeclarators
| TypeSpecifier VariableDeclarators
;

VariableDeclarators
: VariableDeclarator
| VariableDeclarators ',' VariableDeclarator
;

VariableDeclarator
: DeclaratorName
| DeclaratorName '=' VariableInitializer
;

VariableInitializer
: Expression
| '{' '}'
| '{' ArrayInitializers '}'
;

ArrayInitializers
: VariableInitializer
| ArrayInitializers ',' VariableInitializer
| ArrayInitializers ','
;

MethodDeclaration
: Modifiers TypeSpecifier MethodDeclarator Throws MethodBody
| Modifiers TypeSpecifier MethodDeclarator MethodBody
| TypeSpecifier MethodDeclarator Throws MethodBody
| TypeSpecifier MethodDeclarator MethodBody
;

MethodDeclarator
: DeclaratorName '(' ParameterList ')'
| DeclaratorName '(' ')'
| MethodDeclarator OP_DIM
;

ParameterList
: Parameter
| ParameterList ',' Parameter
;

Parameter
: TypeSpecifier DeclaratorName
;

DeclaratorName
: IDENTIFIER
| DeclaratorName OP_DIM
;

Throws
: THROWS ClassNameList
;

MethodBody
: Block
| ';'
;

ConstructorDeclaration
: Modifiers ConstructorDeclarator Throws Block
| Modifiers ConstructorDeclarator Block
| ConstructorDeclarator Throws Block
| ConstructorDeclarator Block
;

ConstructorDeclarator
: IDENTIFIER '(' ParameterList ')'
| IDENTIFIER '(' ')'
;

[HashCodeWithJava]

Java语法文件2

StaticInitializer
: STATIC Block
;

NonStaticInitializer
: Block
;

Extends
: EXTENDS TypeName
| Extends ',' TypeName
;

Block
: '{' LocalVariableDeclarationsAndStatements '}'
| '{' '}'
;

LocalVariableDeclarationsAndStatements
: LocalVariableDeclarationOrStatement
| LocalVariableDeclarationsAndStatements LocalVariableDeclarationOrStatement
;

LocalVariableDeclarationOrStatement
: LocalVariableDeclarationStatement
| Statement
;

LocalVariableDeclarationStatement
: TypeSpecifier VariableDeclarators ';'
;

Statement
: EmptyStatement
| LabeledStatement
| ExpressionStatement ';'
| SelectionStatement
| IterationStatement
| JumpStatement
| GuardingStatement
| Block
;

EmptyStatement
: ';'
;

LabeledStatement
: IDENTIFIER ':' LocalVariableDeclarationOrStatement
| CASE ConstantExpression ':' LocalVariableDeclarationOrStatement
| DEFAULT ':' LocalVariableDeclarationOrStatement
;

ExpressionStatement
: Expression
;

SelectionStatement
: IF '(' Expression ')' Statement
| IF '(' Expression ')' Statement ELSE Statement
| SWITCH '(' Expression ')' Block
;

IterationStatement
: WHILE '(' Expression ')' Statement
| DO Statement WHILE '(' Expression ')' ';'
| FOR '(' ForInit ForExpr ForIncr ')' Statement
| FOR '(' ForInit ForExpr ')' Statement
;

ForInit
: ExpressionStatements ';'
| LocalVariableDeclarationStatement
| ';'
;

ForExpr
: Expression ';'
| ';'
;

ForIncr
: ExpressionStatements
;

ExpressionStatements
: ExpressionStatement
| ExpressionStatements ',' ExpressionStatement
;

JumpStatement
: BREAK IDENTIFIER ';'
| BREAK ';'
| CONTINUE IDENTIFIER ';'
| CONTINUE ';'
| RETURN Expression ';'
| RETURN ';'
| THROW Expression ';'
;

GuardingStatement
: SYNCHRONIZED '(' Expression ')' Statement
| TRY Block Finally
| TRY Block Catches
| TRY Block Catches Finally
;

Catches
: Catch
| Catches Catch
;

Catch
: CatchHeader Block
;

CatchHeader
: CATCH '(' TypeSpecifier IDENTIFIER ')'
| CATCH '(' TypeSpecifier ')'
;

Finally
: FINALLY Block
;

PrimaryExpression
: QualifiedName
| NotJustName
;

NotJustName
: SpecialName
| NewAllocationExpression
| ComplexPrimary
;

ComplexPrimary
: '(' Expression ')'
| ComplexPrimaryNoParenthesis
;

ComplexPrimaryNoParenthesis
: LITERAL
| BOOLLIT
| ArrayAccess
| FieldAccess
| MethodCall
;

ArrayAccess
: QualifiedName '[' Expression ']'
| ComplexPrimary '[' Expression ']'
;

FieldAccess
: NotJustName '.' IDENTIFIER
| RealPostfixExpression '.' IDENTIFIER
;

MethodCall
: MethodAccess '(' ArgumentList ')'
| MethodAccess '(' ')'
;

MethodAccess
: ComplexPrimaryNoParenthesis
| SpecialName
| QualifiedName
;

SpecialName
: THIS
| SUPER
| JNULL
;

ArgumentList
: Expression
| ArgumentList ',' Expression
;

NewAllocationExpression
: ArrayAllocationExpression
| ClassAllocationExpression
| ArrayAllocationExpression '{' '}'
| ClassAllocationExpression '{' '}'
| ArrayAllocationExpression '{' ArrayInitializers '}'
| ClassAllocationExpression '{' FieldDeclarations '}'
;

ClassAllocationExpression
: NEW TypeName '(' ArgumentList ')'
| NEW TypeName '(' ')'
;

ArrayAllocationExpression
: NEW TypeName DimExprs Dims
| NEW TypeName DimExprs
;

DimExprs
: DimExpr
| DimExprs DimExpr
;

DimExpr
: '[' Expression ']'
;

Dims
: OP_DIM
| Dims OP_DIM
;

PostfixExpression
: PrimaryExpression
| RealPostfixExpression
;

RealPostfixExpression
: PostfixExpression OP_INC
| PostfixExpression OP_DEC
;

UnaryExpression
: OP_INC UnaryExpression
| OP_DEC UnaryExpression
| ArithmeticUnaryOperator CastExpression
| LogicalUnaryExpression
;

LogicalUnaryExpression
: PostfixExpression
| LogicalUnaryOperator UnaryExpression
;

LogicalUnaryOperator
: '~'
| '!'
;

ArithmeticUnaryOperator
: '+'
| '-'
;

CastExpression
: UnaryExpression
| '(' PrimitiveTypeExpression ')' CastExpression
| '(' ClassTypeExpression ')' CastExpression
| '(' Expression ')' LogicalUnaryExpression
;

PrimitiveTypeExpression
: PrimitiveType
| PrimitiveType Dims
;

ClassTypeExpression
: QualifiedName Dims
;

MultiplicativeExpression
: CastExpression
| MultiplicativeExpression '*' CastExpression
| MultiplicativeExpression '/' CastExpression
| MultiplicativeExpression '%' CastExpression
;

AdditiveExpression
: MultiplicativeExpression
| AdditiveExpression '+' MultiplicativeExpression
| AdditiveExpression '-' MultiplicativeExpression
;

ShiftExpression
: AdditiveExpression
| ShiftExpression OP_SHL AdditiveExpression
| ShiftExpression OP_SHR AdditiveExpression
| ShiftExpression OP_SHRR AdditiveExpression
;

RelationalExpression
: ShiftExpression
| RelationalExpression '<' ShiftExpression
| RelationalExpression '>' ShiftExpression
| RelationalExpression OP_LE ShiftExpression
| RelationalExpression OP_GE ShiftExpression
| RelationalExpression INSTANCEOF TypeSpecifier
;

EqualityExpression
: RelationalExpression
| EqualityExpression OP_EQ RelationalExpression
| EqualityExpression OP_NE RelationalExpression
;

AndExpression
: EqualityExpression
| AndExpression '&' EqualityExpression
;

ExclusiveOrExpression
: AndExpression
| ExclusiveOrExpression '^' AndExpression
;

InclusiveOrExpression
: ExclusiveOrExpression
| InclusiveOrExpression '|' ExclusiveOrExpression
;

ConditionalAndExpression
: InclusiveOrExpression
| ConditionalAndExpression OP_LAND InclusiveOrExpression
;

ConditionalOrExpression
: ConditionalAndExpression
| ConditionalOrExpression OP_LOR ConditionalAndExpression
;

ConditionalExpression
: ConditionalOrExpression
| ConditionalOrExpression '?' Expression ':' ConditionalExpression
;

AssignmentExpression
: ConditionalExpression
| UnaryExpression AssignmentOperator AssignmentExpression
;

AssignmentOperator
: '='
| ASS_MUL
| ASS_DIV
| ASS_MOD
| ASS_ADD
| ASS_SUB
| ASS_SHL
| ASS_SHR
| ASS_SHRR
| ASS_AND
| ASS_XOR
| ASS_OR
;

Expression
: AssignmentExpression
;

ConstantExpression
: ConditionalExpression
;

%%

[fantasyCoder]

呵呵！
楼上敬业的态度偶佩服！

[HashCodeWithJava]

哈哈，有了这两个文件。运用lex和yacc可以直接就生成Java语言的语法分析器了.

不过麻烦的还在代码生成和优化那一部分。

有谁能来一起干？

[HashCodeWithJava]

Up一下

[javatool]

我想加入，不过我觉得既然要加快速度，就必须自己来写所有的代码。
不要用lex和yacc来生成代码.

[EricZhuo]

java编译速度挺快的阿，慢的是运行速度。不要搞混了

[HashCodeWithJava]

是啊.
就算是编译程序,
而且lex和yacc生成的程序速度肯定比自己写的快嘛。
flex和bison生成的都是运用了世界上比较先进的算法了.

至于代码生成部分，我就没好生学了.:-(

有高手否？

[HashCodeWithJava]

加我吧
QQ: 8664220
msn: [e-mail]

注明: Java之子

[apogeecsj]

做个普通的虚拟机比较简单，但要做编译器的话，有难度，一个人很难搞定

[HashCodeWithJava]

就是，就是.
我只做过普通的双栈的虚拟机。

不过生成直接的代码倒没搞过，听说有这方面的工具

[aijm]

做个javac ? 不知楼主要实现成什么样子？
要支持java所有的 api，直接生成机器码。好像很难做到吧。
反而做成虚拟机的方式更好。多线程，applet ..有可能的话加上泛型..呵呵，一个人做太难的吧！

[wilddonkey]

guan zhu

[HashCodeWithJava]

大家好，我已经快完成了语法树的生成了。
我的开发步骤大致分三步骤。

1。填写上面的Yacc文法文件的识别每个非终结符的动作，生成语法树

2。注释语法树，计算文法属性。

3。代码生成。


等测试通过后，那么就可以进入注释语法阶段了.