Goal	=	MainClass, { ClassDeclaration }, EOF;
MainClass	=	"class", Identifier, "{", "public", "static", "void", "main", "(", "String", "[", "]", Identifier, ")", "{", Statement, "}", "}";
ClassDeclaration	=	"class", Identifier, [ "extends", Identifier ], "{", { VarDeclaration }, { MethodDeclaration } "}";
VarDeclaration	=	Type, Identifier, ";";
MethodDeclaration	=	"public", Type, Identifier, "(", [ Type, Identifier, { ",", Type, Identifier }, ], ")", "{", { VarDeclaration }, { Statement }, "return", Expression, ";", "}";
Type	=	"int", "[", "]"
	|	"boolean"
	|	"int"
	|	Identifier
	;
Statement	=	"{", { Statement }, "}"
	|	"if", "(", Expression, ")", Statement, "else", Statement
	|	"while", "(", Expression, ")", Statement
	|	"System.out.println", "(" , Expression, ")", ";"
	|	Identifier, "=", Expression, ";"
	|	Identifier, "[", Expression, "]", "=", Expression, ";"
	;
Expression	=	Expression , ( "&&" | "<" | "+" | "-" | "*" ) , Expression
	|	Expression, "[", Expression, "]"
	|	Expression, ".", "length"
	|	Expression, ".", Identifier, "(", [ Expression { ",", Expression } ], ")"
	|	IntegerLiteral
	|	"true"
	|	"false"
	|	Identifier
	|	"this"
	|	"new", "int", "[", Expression, "]"
	|	"new", Identifier ,"(" ,")"
	|	"!", Expression
	|	"(", Expression, ")"
	;
Identifier	is	one or more letters, digits, and underscores, starting with a letter
IntegerLiteral	is	one or more decimal digits
EOF	is	a distinguished token returned by the scanner at end-of-file

Comments

/*
            One commment
            /*  Nested comment */
            Bad things will happen
            */
            

Appel, 2nd edition, page 484, describes comments in MiniJava as being nestable. This is an interesting exercise for the scanner, but is not required.

EBNF

• Terminal symbols are quoted
• [ and ] indicate optional symbols
• { and } indicate repetition
• ( and ) group items together; the other brackets do too

  SET_TYPES = { "bool", "char", "float", "int", "string" }
  SET_LITERALS = { <boolean_literal>, <char_literal>, <float_literal>, <int_literal>, <string_literal> }
  SET_INSTRUCTIONS = { "label", "break", "continue", "if", "goto", "while", "do", "switch", "return", ";" }
  SET_UNARIES = { "&", "*", "~", "+", "-", "!" }
 

module

    module:               "module" <identifier> ";" globals.
 

globals

    globals:              e.
    globals:              global globals.
    globals:              "extern" global globals.
 

global

    global:               function.
    global:               declaration.
 

function

    function:             functionheader functionrest.
 

functionheader

    functionheader:       modifiers <identifier> ":" paramlist "->" returntype.
 

functionrest

    functionrest:         ";".
    functionrest:         block.
 

modifiers:

    modifiers:            e.
    modifiers:            "start".
 

paramlist

    paramlist:            "void".
    paramlist:            paramblock moreparamblocks.
 

moreparamblocks

    moreparamblocks:      e.
    moreparamblocks:      ";" paramblock moreparamblocks.
 

paramblock

    paramblock:           type param moreparams.
 

moreparams

    moreparams:           e.
    moreparams:           "," param moreparams.
 

param

    param:                reference <identifier> dimensionblock.
 

returntype

    returntype:           type reference dimensionblock.
 

reference

    reference:            e.
    reference:            "*" reference.
 

dimensionblock

    dimensionblock:       e.
    dimensionblock:       "[" "]" dimensionblock.
 

block

    block:                "{" code "}".
 

code

    code:                 e.
    code:                 block code
    code:                 statement code.
 

statement

    statement:            "label" <identifier> ";"
    statement:            ";"
    statement:            "break" ";"
    statement:            "continue" ";"
    statement:            expression ";"
    statement:            declarationblock ";"
    statement:            "if" "(" expression ")" block elseblock
    statement:            "goto" <identifier> ";"
    statement:            "while" "(" expression ")" "do" block
    statement:            "do" block "while" "(" expression ")" ";"
    statement:            "switch" "(" expression ")" "{" switchcases "default" block "}"
    statement:            "return" returnarg ";".
 

returnarg

    returnarg:            "(" expression ")".
    returnarg:            e.
 

elseblock

    elseblock:            e.
    elseblock:            "else" block.
 

switchcases

    switchcases:          e.
    switchcases:          "case" <int_literal> block swithcases.
 

declarationblock

    declarationblock:     type declaration restdeclarations.
 

restdeclarations

    restlocals:           e.
    restlocals:           "," declaration restdeclarations.
 

declaration

    local:                reference <identifier> indexblock initializer.
 

indexblock

    indexblock:           e.
    indexblock:           "[" <int_literal> "]" indexblock.
 

initializer

    initializer:          e.
    initializer:          "=" expression.
 

expression

    expression:           logicalor restexpression.
 

restexpression

    restexpression:       e.
    restexpression:       "=" logicalor restexpression.
 

logicalor

    logicalor:            logicaland restlogicalor.
 

restlogicalor

    restlogicalor:        e.
    restlogicalor:        "||" logicaland restlogicalor.
 

logicaland

    logicaland:           bitwiseor restlogicaland.
 

restlogicaland

    restlogicaland:       e.
    restlogicaland:       "&&" bitwiseor restlogicaland.
 

bitwiseor

    bitwiseor:            bitwisexor restbitwiseor.
 

restbitwiseor

    restbitwiseor:        e.
    restbitwiseor:        "|" bitwisexor restbitwiseor.
 

bitwisexor

    bitwisexor:           bitwiseand restbitwisexor.
 

restbitwisexor

    restbitwisexor:       e.
    restbitwisexor:       "^" bitwiseand restbitwisexor.
 

bitwiseand

    bitwiseand:           equality restbitwiseand.
 

restbitwiseand

    restbitwiseand:       e.
    restbitwiseand:       "&" equality restbitwiseand.
 

equality

    equality:             relation restequality.
 

restequality

    restequality:         e.
    restequality:         equalityoperator relation restequality.
 

equalityoperator

    equalityoperator:     "==".
    equalityoperator:     "!=".
 

relation

    relation:             shift restrelation.
 

restrelation

    restrelation:         e.
    restrelation:         relationoperator shift restrelation.
 

relationoperator

    relationoperator:     "<".
    relationoperator:     "<=".
    relationoperator:     ">".
    relationoperator:     ">=".
 

shift

    shift:                addition restshift.
 

restshift

    restshift:            e.
    restshift:            shiftoperator addition restshift.
 

shiftoperator

    shiftoperator:        "<<".
    shiftoperator:        ">>".
 

addition

    addition:             multiplication restaddition.
 

restaddition

    restaddition:         e.
    restaddition:         additionoperator multiplication restaddition.
 

additionoperator

    additionoperator:     "+".
    additionoperator:     "-".
 

multiplication

    multiplication:       unary3 restmultiplication.
 

restmultiplication

    restmultiplication:   e.
    restmultiplication:   multiplicationoperator unary3 restmultiplication.
 

multiplicationoperator

    multiplicationoperator: "*".
    multiplicationoperator: "/".
    multiplicationoperator: "%".
 

unary3

    unary3:               unary2
    unary3:               unary3operator unary3.
 

unary3operator:

    unary3operator:       "&".
    unary3operator:       "*".
    unary3operator:       "~".
 

unary2

    unary2:               factor.
    unary2:               unary2operator unary2.
 

unary2operator

    unary2operator:       "+".
    unary2operator:       "-".
    unary2operator:       "!".
 

factor

    factor:               <identifier> application.
    factor:               immediate.
    factor:               "(" expression ")".
 

application

    application:          e.
    application:          "[" expression "]" application.
    application:          "(" expression moreexpressions ")".
 

moreexpressions

    moreexpressions:      e.
    moreexpressions:      "," expression morexpressions.
 

type

    type:                 "bool".
    type:                 "char".
    type:                 "float".
    type:                 "int".
    type:                 "string".
 

immediate

    immediate:            <boolean_literal>.
    immediate:            <char_literal>.
    immediate:            <float_literal>.
    immediate:            <int_literal>.
    immediate:            <string_literal>.

module

    module:               "module" <identifier> ";" {[extern] global}.
 

global

    global:               function | declaration.
 

Functions

function

    function:             functionheader [ ";" | block ].
 

functionheader

    functionheader:       ["start"] <identifier> ":" paramlist "->" returntype.
 

paramlist

    paramlist:            "void" | paramblock {";" paramblock}.
 

paramblock

    paramblock:           type param {"," param}.
 

param

    param:                {"*"} <identifier> {"[" "]"}.
 

returntype

    returntype:           type {"*"} {"[" "]"}.
 

Blocks and statements

block

    block:                "{" { statement | block } "}".
 

statement

    statement:            "label" <identifier> ";"
    statement:            ";"
    statement:            "break" ";"
    statement:            "continue" ";"
    statement:            expression ";"
    statement:            declarationblock ";"
    statement:            "if" "(" expression ")" block [ "else" block ].
    statement:            "goto" <identifier> ";"
    statement:            "while" "(" expression ")" "do" block
    statement:            "do" block "while" "(" expression ")" ";"
    statement:            "switch" "(" expression ")" "{" { "case" <int_literal> block } "default" block "}"
    statement:            "return" "(" expression ")"

 ";".
 

declarationblock

    declarationblock:     type declaration {"," declaration}.
 

declaration

    local:                {"*"} <identifier> {"[" <int_literal> "]"} [ "=" expression ].
 

Expressions

Assignment

    expression:           logicalor {"=" logicalor expression}.
 

Logical OR

    logicalor:            logicaland {"||" logicaland logicalor}.
 

Logical AND

    logicaland:           bitwiseor {"&&" bitwiseor logicaland}.
 

Bitwise OR

    bitwiseor:            bitwisexor {"|" bitwisexor bitwiseor}.
 

Bitwise XOR

    bitwisexor:           bitwiseand {"^" bitwiseand bitwisexor}.
 

Bitwise AND

    bitwiseand:           equality {"&" equality bitwiseand}.
 

Equality

    equality:             relation {("==" | "!=") relation equality}.
 

Relation

    relation:             shift {("<" | "<=" | ">" | ">=") shift relation}.
 

Bitwise shift

    shift:                addition {("<<" | ">>") addition shift}.
 

Addition/subtraction

    addition:             multiplication {("+" | "-") multiplication addition}
 

Multiplication/division

    multiplication:       unary3 {("*" | "/" | "%") unary3 multiplication}.
 

Unary operations

Reference, indirection and bitwise complement

    unary3:               {("&" | "*" | "~")} unary2.
 

Unary negation, unary plus and logical NOT

    unary2:               {("+" | "-" | "!")} factor.
 

Factor and application

factor

    factor:               <identifier> [application] | immediate | "(" expression ")".
 

application

    application:          "[" expression "]" application | "(" expression {"," expression } ")".
 

Types and immediates

type

    type:                 "bool" | "char" | "float" | "int" | "string".
 

immediate

    immediate:            <boolean_literal> | <char_literal> | <float_literal> | <int_literal> | <string_literal>.

        /* Call the preprocessor. It will store its result in
         * preprocessorFilename. If the preprocessor could not
         * open the input file, skip this file.
         * 建立一个新文件，文件名为原来的.i文件加上.p,如果输入的
            文件名是while.i,则生成的经过预处理的文件名为while.i_p，
            这里说的预处理和c语言是一样的，即将相应的头文件拷贝过来，
            如#import "printint.ih"，则将#import "printint.ih"替换为
            printint.ih文件的内容
         */
        result = Preprocess( argv[optind], preprocessorFilename );

词法分析：
关键字定义:

/* This enum contains all the keywords and operators
 * used in the language.
 */
enum
{
    /* Keywords */
    KW_BREAK            = 1000, /* "break" keyword */
    KW_CASE,                    /* "case" keyword */
    KW_CONTINUE,                /* "continue" keyword */
    KW_DEFAULT,                 /* "default" keyword */
    KW_DO,                      /* "do" keyword */
    KW_ELSE,                    /* "else" keyword */
    KW_EXTERN,                  /* "extern" keyword */
    KW_GOTO,                    /* "goto" keyword */
    KW_IF,                      /* "if" keyword */
    KW_LABEL,                   /* "label" keyword */
    KW_MODULE,                  /* "module" keyword */
    KW_RETURN,                  /* "return"keyword */
    KW_START,                   /* "start" keyword */
    KW_SWITCH,                  /* "switch" keyword */
    KW_WHILE,                   /* "while" keyword */

    /* Type identifiers */
    KW_BOOL,                    /* "bool" identifier */
    KW_CHAR,                    /* "char" identifier */
    KW_FLOAT,                   /* "float" identifier */
    KW_INT,                     /* "int" identifier */
    KW_UNTYPED,                 /* "untyped" identifier */
    KW_VOID,                    /* "void" identifier */

    /* Variable lexer tokens */
    LIT_BOOL,                   /* bool constant */
    LIT_CHAR,                   /* character constant */
    LIT_FLOAT,                  /* floating point constant */
    LIT_INT,                    /* integer constant */
    LIT_STRING,                 /* string constant */
    IDENTIFIER,                 /* identifier */

    /* Operators */
    OP_ADD,                     /* "+"  */
    OP_ASSIGN,                  /* "="  */
    OP_BITWISE_AND,             /* "&" */
    OP_BITWISE_COMPLEMENT,      /* "~"  */
    OP_BITWISE_LSHIFT,          /* "<<" */
    OP_BITWISE_OR,              /* "|" */
    OP_BITWISE_RSHIFT,          /* ">>" */
    OP_BITWISE_XOR,             /* "^"  */
    OP_DIVIDE,                  /* "/"  */
    OP_EQUAL,                   /* "==" */
    OP_GREATER,                 /* ">"  */
    OP_GREATEREQUAL,            /* ">=" */
    OP_LESS,                    /* "<"  */
    OP_LESSEQUAL,               /* "<=" */
    OP_LOGICAL_AND,             /* "&&" */
    OP_LOGICAL_OR,              /* "||" */
    OP_MODULUS,                 /* "%"  */
    OP_MULTIPLY,                /* "*"  */
    OP_NOT,                     /* "!"  */
    OP_NOTEQUAL,                /* "!=" */
    OP_SUBTRACT,                /* "-"  */
    OP_TERNARY_IF,              /* "?"  */
  
    /* Delimiters */
    ARROW,                      /* "->" */
    LBRACE,                     /* "{"  */
    RBRACE,                     /* "}"  */
    LBRACKET,                   /* "["  */
    RBRACKET,                   /* "]"  */
    COLON,                      /* ":"  */
    COMMA,                      /* ","  */
    LPAREN,                     /* "("  */
    RPAREN,                     /* ")"  */
    SEMICOLON                   /* ";"  */
}
tokens;

处理inger中的各种数据类型和标识符，如BOOL, unsigned long, float, char*,标识符等
typedef union
{
    unsigned long  uintvalue;
    BOOL    boolvalue;
    char   *stringvalue;
    char    charvalue;
    float   floatvalue;
    char   *identifier;
} Tokenvalue;

树节点结构(注意：树节点和抽象语法树节点是不同的)：
typedef struct TreeNode
{
    void            *data;
    int              screenX;
    struct TreeNode *parent;
    List            *children; //一系列孩子
} TreeNode;

抽象语法树节点结构：
typedef struct AstNode
{
    int         id;  //表示节点的类型，如while节点，module节点
    Tokenvalue  val;
    Type       *type;
    int         lineno;
} AstNode;

抽象语法树的AstNode作为TreeNode的data成员保存，参考如下函数：
//参数id表示节点名，如：NODE_MODULE,NODE_GLOBAL等见nodenames.h
TreeNode *CreateAstNode( int id, int lineno )
{
    TreeNode *treeNode;
    AstNode *astNode;

    astNode = (AstNode *) MallocEx( sizeof( AstNode ) );
    astNode->id = id;
    astNode->lineno = lineno;
    astNode->val.uintvalue = 0;
    astNode->type = NULL;
    treeNode = CreateTreeNode( astNode );

    return( treeNode );
}
或者：
TreeNode *CreateAstNodeVal( int id, Tokenvalue val, int lineno )
{
    TreeNode *treeNode;
    AstNode *astNode;

    astNode = (AstNode *) MallocEx( sizeof( AstNode ) );
    astNode->id = id;
    astNode->lineno = lineno;
    astNode->val = val;
    astNode->type = NULL;
    treeNode = CreateTreeNode( astNode );

    return( treeNode );
}

//抽象语法树节点名
enum NodeNames
{
    NODE_MODULE = 0,
    NODE_START,
    NODE_EXTERN,
    NODE_GLOBAL,
    NODE_FUNCTION,
    NODE_FUNCTIONHEADER,
    NODE_MODIFIERS,
    NODE_PARAMLIST,
    NODE_PARAMBLOCK,
    NODE_PARAM,
    NODE_RETURNTYPE,
    NODE_DIMENSION,
    NODE_DIMENSIONBLOCK,
    NODE_BLOCK,
    NODE_STATEMENT,
    NODE_SWITCH,
    NODE_CASES,
    NODE_CASE,
    NODE_WHILE,
    NODE_GOTO,
    NODE_LABEL,
    NODE_IF,
    NODE_IDENT,
    NODE_RETURN,
    NODE_CONTINUE,
    NODE_BREAK,
    NODE_DECLBLOCK,
    NODE_DECLARATION,
    NODE_INITIALIZER,
    NODE_INDEXBLOCK,
    NODE_REFERENCE,
    NODE_INDEX,
    NODE_EXPRESSION,
    NODE_LOGICAL_OR,
    NODE_LOGICAL_AND,
    NODE_BITWISE_OR,
    NODE_BITWISE_XOR,
    NODE_BITWISE_AND,
    NODE_EQUAL,
    NODE_NOTEQUAL,
    NODE_GREATER,
    NODE_GREATEREQUAL,
    NODE_LESS,
    NODE_LESSEQUAL,
    NODE_BITWISE_LSHIFT,
    NODE_BITWISE_RSHIFT,
    NODE_ASSIGN,
    NODE_BINARY_ADD,
    NODE_BINARY_SUBTRACT,
    NODE_UNARY_ADD,
    NODE_UNARY_SUBTRACT,
    NODE_MULTIPLY,
    NODE_DIVIDE,
    NODE_MODULUS,
    NODE_BITWISE_COMPLEMENT,
    NODE_ADDRESS,
    NODE_DEREFERENCE,
    NODE_NOT,
    NODE_APPLICATION,
    NODE_INDEXER,
    NODE_ARGUMENTS,
    NODE_FACTOR,

    NODE_BOOL,
    NODE_CHAR,
    NODE_FLOAT,
    NODE_INT,
    NODE_UNTYPED,
    NODE_VOID,

    NODE_LIT_BOOL,
    NODE_LIT_CHAR,
    NODE_LIT_FLOAT,
    NODE_LIT_INT,
    NODE_LIT_STRING,
    NODE_LIT_IDENTIFIER,

    NODE_INT_TO_FLOAT,
    NODE_CHAR_TO_INT,
    NODE_CHAR_TO_FLOAT,

    NODE_UNKNOWN = -1
};

输出抽象语法树：
/*
 * PRINTING ROUTINES
 */
void PrintAst( TreeNode *source )
{
    PrintTree( source, GetAstNodeData, 4 );
}
PrintTree的实现如下，这里传递的参数levels等于4
void PrintTree( TreeNode *source, DataFunction dataFunction, int levels )
{
    int printDepth = 0;
    BOOL loop;
    char *str;
    int i;

    /* TODO: We're going to have to make a new macro.
     * Don't use DEBUG for this.
     */
    DEBUG( "Called\n" );

    /* If tree is empty, abort. */
    if( source == NULL )
    {
        return;
    }

    /* Walk through tree to determine x-offsets for
     * each node.
     */
    LayoutTree( source, LEFT_OFFSET );

/* Print nodes. */
依次通过调用函数指针dataFunction所指向的函数(实际上是函数GetAstNodeData)
来输出每个节点的节点名，节点的token的值，类型名，以及行号，参考下面的GetAstNodeData函数

    for( i = 0; i < levels; i++ )
    {
        str = dataFunction( source, i );
        PrintChars( source->screenX - strlen( str ) / 2, ' ' );
        printf( "%s\n", str );
    }
    PrintChars( source->screenX, ' ' );
    printf( "%c", VERTBAR );

    printDepth = 0;
    do
    {
        currentX = 0;
        printf("\n");
        PrintNode( source, 0, printDepth, 0, dataFunction, 0 );
        currentX = 0;
        printf("\n");
        PrintNode( source, 0, printDepth, 1, dataFunction, 0 );
        currentX = 0;
        printf("\n");
        for( i = 0; i < levels; i++ )
        {
            PrintNode( source, 0, printDepth, 2, dataFunction, i );
            currentX = 0;
            printf("\n");
        }
        loop = PrintNode( source, 0, printDepth, 3, dataFunction, 0 );
        printDepth++;
    }
    while( loop );
}

添加一个孩子的操作只需要将新节点插入到孩子链表尾部即可
void AddTreeChild( TreeNode *parentnode, TreeNode *node )
{
    /* Do not act on an empty node. */
    if( node == NULL ) return;

    /* If the tree is empty, add the first root node. */
    if( parentnode == NULL )
    {
       node->parent = NULL;
    }
    else
    /* Tree is not empty. Add the new node to [parentnode]'s
     * children list. */
    {
       node->parent = parentnode;

       ListAppend( parentnode->children, node );
    }
}

而RemoveAstNode则删除整个子树
/* Remove node [node] from ast. The node contents
 * and its children get deleted.
 *
 * Pre:  [node] is not NULL.
 */
void RemoveAstNode( TreeNode *node );

inger编译流程：
1. 预处理，关键函数为Preprocess
2. 语法分析，构建抽象语法树，关键函数Parse，Parse也是构造抽象语法树的入口函数，如果语法分析没有发现错误则跳到第3步
3. 根据抽象语法树来建立符号表关键函数为CreateSymbolTable( ast );
4. 语义分析，关键函数：
a) CheckLeftValues( ast );
b) CheckArgCount( ast );
c) CheckSwitchStatements( ast );
d) CheckFunctionReturns( ast );

5.  根据抽象语法树生成代码，关键函数GenerateCode( ast );

 

 

ngaut 2008-01-03 23:14 发表评论

]]>

" ^\d+$ " 　　 // 非负整数（正整数 + 0） 
" ^[0-9]*[1-9][0-9]*$ " 　　 // 正整数 
" ^((-\d+)|(0+))$ " 　　 // 非正整数（负整数 + 0） 
" ^-[0-9]*[1-9][0-9]*$ " 　　 // 负整数 
" ^-?\d+$ " 　　　　 // 整数 
" ^\d+(\.\d+)?$ " 　　 // 非负浮点数（正浮点数 + 0） 
" ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$ " 　　 // 正浮点数 
" ^((-\d+(\.\d+)?)|(0+(\.0+)?))$ " 　　 // 非正浮点数（负浮点数 + 0） 
" ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$ " 　　 // 负浮点数 
" ^(-?\d+)(\.\d+)?$ " 　　 // 浮点数 
" ^[A-Za-z]+$ " 　　 // 由26个英文字母组成的字符串 
" ^[A-Z]+$ " 　　 // 由26个英文字母的大写组成的字符串 
" ^[a-z]+$ " 　　 // 由26个英文字母的小写组成的字符串 
" ^[A-Za-z0-9]+$ " 　　 // 由数字和26个英文字母组成的字符串 
" ^\w+$ " 　　 // 由数字、26个英文字母或者下划线组成的字符串 
" ^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$ " 　　　　 // email地址 
" ^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$ " 　　 // url
/^ (d { 2 } | d { 4 } ) - (( 0 ([ 1 - 9 ] { 1 } )) | ( 1 [ 1 | 2 ])) - (([ 0 - 2 ]([ 1 - 9 ] { 1 } )) | ( 3 [ 0 | 1 ]))$ /     //   年-月-日
/^ (( 0 ([ 1 - 9 ] { 1 } )) | ( 1 [ 1 | 2 ])) / (([ 0 - 2 ]([ 1 - 9 ] { 1 } )) | ( 3 [ 0 | 1 ])) / (d { 2 } | d { 4 } )$ /     //  月/日/年
" ^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$ "     // Emil
" (d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)? "       // 电话号码
" ^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$ "     // IP地址

匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配网址URL的正则表达式：^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
匹配国内电话号码：(\d{3}-|\d{4}-)?(\d{8}|\d{7})?
匹配腾讯QQ号：^[1-9]*[1-9][0-9]*$

下表是元字符及其在正则表达式上下文中的行为的一个完整列表：

\ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。

^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性，^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。

$ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性，$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。

* 匹配前面的子表达式零次或多次。

+ 匹配前面的子表达式一次或多次。+ 等价于 {1,}。

? 匹配前面的子表达式零次或一次。? 等价于 {0,1}。

{n} n 是一个非负整数，匹配确定的n 次。

{n,} n 是一个非负整数，至少匹配n 次。

{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。在逗号和两个数之间不能有空格。

? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。

. 匹配除 "\n" 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符，请使用象 ’[.\n]’ 的模式。
(pattern) 匹配pattern 并获取这一匹配。

(?:pattern) 匹配pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。

(?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。

(?!pattern) 负向预查，与(?=pattern)作用相反

x|y 匹配 x 或 y。

[xyz] 字符集合。

[^xyz] 负值字符集合。

[a-z] 字符范围，匹配指定范围内的任意字符。

[^a-z] 负值字符范围，匹配任何不在指定范围内的任意字符。

\b 匹配一个单词边界，也就是指单词和空格间的位置。

\B 匹配非单词边界。

\cx 匹配由x指明的控制字符。

\d 匹配一个数字字符。等价于 [0-9]。

\D 匹配一个非数字字符。等价于 [^0-9]。

\f 匹配一个换页符。等价于 \x0c 和 \cL。

\n 匹配一个换行符。等价于 \x0a 和 \cJ。

\r 匹配一个回车符。等价于 \x0d 和 \cM。

\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

\t 匹配一个制表符。等价于 \x09 和 \cI。

\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。

\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。

\W 匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。

\xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。

\num 匹配 num，其中num是一个正整数。对所获取的匹配的引用。

\n 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

\nm 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

\nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。

\un 匹配 n，其中 n 是一个用四个十六进制数字表示的Unicode字符。

匹配中文字符的正则表达式： [u4e00-u9fa5]

匹配双字节字符(包括汉字在内)：[^x00-xff]

应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String.prototype.len=function(){return this.replace([^x00-xff]/g,"aa").length;}

匹配空行的正则表达式：n[s| ]*r

匹配HTML标记的正则表达式：/<(.*)>.*</1>|<(.*) />/

匹配首尾空格的正则表达式：(^s*)|(s*$)

应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：

String.prototype.trim = function()
{
return this.replace(/(^s*)|(s*$)/g, "");
}

利用正则表达式分解和转换IP地址：

下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：

function IP2V(ip)
{
re=/(d+).(d+).(d+).(d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*

匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

利用正则表达式去除字串中重复的字符的算法程序：

var s="abacabefgeeii"
var s1=s.replace(/(.).*1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //结果为：abcefgi

我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。

得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*/){0,}([^.]+).*/ig,"$2")
alert(s)

利用正则表达式限制网页表单里的文本框输入内容：

用 正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^u4E00-u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^u4E00-u9FA5]/g,''))"

用 正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^uFF00-uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^uFF00-uFFFF]/g,''))"

用 正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

用 正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

当词法分析器与说明文件规则部分中的一个扩展正则表达式匹配时，它执行与扩展正则表达式相对应的操作。没有足够的规则匹配输入流中的所有字符串，词法分析器则将输入复制到标准输出。因此，不要创建仅将输入复制到输出的规则。缺省的输出能够帮助在规则中查找间隔。

当使用 lex 命令处理由 yacc 命令产生的解析器的输入时，请提供与所有输入字符串匹配的规则。那些规则必须生成 yacc 命令能够解释的输出。

空操作

要忽略与扩展正则表达式关联的输入，请使用 ;（C 语言空语句）作为操作。下面的示例忽略了三个间隔字符（空白、制表符和换行）：

[ \t\n] ;

与下一个操作相同

要避免反复写相同的操作，请使用 |（管道符号）。此字符指示此规则的操作与下一条规则的操作相同。例如，先前忽略空白、制表符和换行字符的示例也可写成：

" "                     |
"\t"                    |
"\n"                    ;

\n 和 \t 两边的引号并不需要。

打印匹配字符串

要确定哪个文本与说明文件的规则部分的表达式匹配，您可以包扩 C 语言 printf 子例程调用作为该表达式的一个操作。当词法分析器在输入流中找到匹配，程序将匹配字符串放入外部字符（char）和宽字符（wchar_t）数组中，分别称为 yytext 和 yywtext。例如，您能使用下面的规则打印匹配字符串：

[a-z]+            printf("%s",yytext);

C 语言 printf 子例程接受格式参数和要打印的数据。在此示例中，printf 子例程的参数具有下面的含义：

lex 命令定义 ECHO；作为要打印 yytext 的内容的特殊操作。例如，下面的两条规则是等价的：

[a-z]+       ECHO;
[a-z]+       printf("%s",yytext);

您可以在 lex 说明文件的定义部分使用 %array 或者 %pointer 如下更改 yytext 的说明：

查找匹配字符串的长度

要查找词法分析器与特定的扩展正则表达式所匹配的字符数，请使用 yyleng 或者 yywleng 外部变量。

要对输入的字数和字中的字符数进行计数，请使用下面的操作：

[a-zA-Z]+       {words++;chars += yyleng;}

此操作总计匹配的字中的字符数，并将该数字赋予 chars。

下面的表达式在匹配字符串中查找最后一个字符：

yytext[yyleng-1]

匹配字符串中的字符串

lex 命令对输入流进行分区，并不搜索每个表达式的所有可能的匹配字符串。每个字符仅计算一次。要覆盖此选项并搜索可能重叠或者互相包含的项，请使用 REJECT 操作。例如，要对 she 和 he 的所有实例（包括包含在 she 中的 he）计数，请使用下面的操作：

she              {s++; REJECT;}
he               {h++}
\n          |.           ;

在对 she 的出现次数进行计数后，lex 命令拒绝输入字符串，然后对 he 的出现次数进行计数。因为 he 并不包括 she，所以 REJECT 操作不必在 he 上。

将结果添加到 yytext 数组

典型情况下，来自输入流的下一个字符串覆盖 yytext 数组中的当前项。如果您使用 yymore 子例程，来自输入流的下一个字符串将被添加到 yytext 数组的当前项的尾部。

例如，下面的词法分析器搜索字符串：

%s instring
%%
<INITIAL>\"     {  /* start of string */
         BEGIN instring;
         yymore();
        }
<instring>\"    {  /* end of string */
         printf("matched %s\n", yytext);
         BEGIN INITIAL;
        }
<instring>.     {
         yymore();
        }
<instring>\n    {
         printf("Error, new line in string\n");
         BEGIN INITIAL;
        }

尽管通过匹配多个规则，字符串可能被识别，但是反复调用 yymore 子例程可以确保 yytext 数组包含整个字符串。

将字符返回到输入流

要将字符返回给输入流，请使用下面的调用：

yyless(n)

其中 n 是当前字符串中要保持的字符数。字符串中超过此数目的字符被返回到输入流。yyless 子例程提供的先行函数类型与 /（斜杠）运算符所使用的相同，但是它允许更多对其用法的控制。

不止一次使用 yyless 子例程处理文本。例如，当语法分析 C 语言程序时，诸如 x=-a 之类的表达式很难理解。它表示 x等于-a，还是 x -= a 的旧的表述形式（意味着将 x减去值a）？要将此表达式作为 x等于-a 处理，但是要打印警告消息则请使用如下的规则：

=-[a-zA-Z]      {
                printf("Operator (=-) ambiguous\n");
                yyless(yyleng-1);
                ... action for = ...
                }

输入／输出子例程

lex 程序允许程序使用下述输入／输出（I/O）子例程：

lex 程序提供这些子例程作为宏定义。子例程的代码在 lex.yy.c 文件中。您能覆盖它们并提供其他版本。

定义 winput、wunput 和 woutput 宏以使用 yywinput、yywunput 和 yywoutput 子例程。考虑到兼容性，yy 子例程随后使用 input、unput 和 output 子例程来读、写和替换完全多字节字符中需要数目的字节。

这些子例程定义外部文件和内部字符之间的关系。如果您更改子例程，请以相同的方式将它们全部更改。这些子例程应该遵循这些规则：

• 所有的子例程必须使用相同的字符集。
• input 子例程必须返回 0 值以指示文件的末尾。
• 不要更改 unput 子例程和 input 子例程的关系，否则先行函数会不起作用。

lex.yy.c 文件允许词法分析器最多备份 200 个字符。

要读包含 NULL 的文件，请创建不同版本的 input 子例程。在 input 子例程的正常版本中，（从空字符）返回的值 0 表明这是文件的末尾，且将终止输入。

字符集

lex 命令生成的词法分析器通过 input、output 和 unput 子例程处理字符 I/O。因此，要在 yytext 子例程中返回值，lex 命令使用这些子例程使用的字符说明。但是，在内部 lex 命令使用小整数代表每一个字符。当使用标准库时，此整数是计算机用来表示字符的位模式的值。正常情况下，字母 a 用与字符常量 a 相同的格式表示。如果您使用不同的 I/O 子例程更改此解释，请将转换表放到说明文件的定义部分。转换表在包含下述条目的行开始和结束：

%T

转换表包含指示与每个字符关联的值的其他行。例如：

%T
{integer}       {character string}
{integer}       {character string}
{integer}       {character string}
%T

文件末尾处理

当词法分析器到达文件末尾时，它调用 yywrap 库子例程，此调用返回值 1，指示词法分析器应该继续在输入末尾正常结束。

但是，如果词法分析器从多个源接收到输入，请更改 yywrap 子例程。新的函数必须获取新的输入并将值 0 返回给词法分析器。返回值 0 指示程序应该继续处理。

您也可以包含代码，以在词法分析器在新版本的 yywrap 子例程中终止时，打印摘要报告和表。yywrap 子例程是强制 yylex 子例程识别输入末尾的唯一途径。

java(gjc)词法分析器优点：
  1.所有的源文件一次读入到内存缓冲区buf[]中，对随后的操作有一定的简化作用，
    并使得词法分析速度有一定的提高。
  2.词法分析的出错点报告精确到具体的行和列：line, col。觉得没有必要精确到列。
  3.通过scanChar()来预读一个字符，然后根据预读的字符来推测该token可能的类型
    然后调用相应的函数来处理。抽象程度更高，值得学习。
   
 
 

When the scanner receives an end-of-file indication from YY_INPUT, it then checks the `yywrap()' function. If `yywrap()' returns false (zero), then it is assumed that the function has gone ahead and set up yyin to point to another input file, and scanning continues. If it returns true (non-zero), then the scanner terminates, returning 0 to its caller. Note that in either case, the start condition remains unchanged; it does not revert to INITIAL.

If you do not supply your own version of `yywrap()', then you must either use `%option noyywrap' (in which case the scanner behaves as though `yywrap()' returned 1), or you must link with `-lfl' to obtain the default version of the routine, which always returns 1.