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 但不获取匹配结果，也就�