• 1029 C语言文法


    program    ->                                            

           external_declaration

          | program external_declaration 

                         

    <程序> ->  <外部声明> |  <程序>  <外部声明>

    external_declaration ->      function_definition

          | declaration

    <外部声明>  ->   <函数定义>  |  <声明>

    function_definition -> type_specifier declarator compound_statement

    <函数定义>  ->  <说明符类型>  <声明> <复合语句>

    type_specifier ->     

    VOID

          | CHAR

          | INT

          | FLOAT

     <说明符类型>  ->  <空类> | <字符型> |  <浮点型>

    declarator

          pointer direct_declarator

          | direct_declarator

     <声明> ->  <指针>  <直接说明符>  |  <直接说明符>

    Pointerà

          '*'

          | '*' pointer

    <指针> -> <*> | <*指针>

    direct_declarator

          IDENTIFIER

       |direct_declarator’[‘ ‘]’

          |direct_declarator ’[’ constant_expression ’]’

          | IDENTIFIER '(' parameter_list ')'

    | IDENTIFIER '('  ')'

          |direct_declarator  ‘,’  identifier_list

    <直接说明符>  -> <标识符>  |  <直接说明符  '['  ']'>   |  <直接标识符'[' 恒表达式 ']'>  |  <标识符'(' 参数名单 ')'>  |  <标识符'('  ')'>  |  <直接说明符 ';' 识别名单>

    identifier_list

          : IDENTIFIER

          | identifier_list ',' IDENTIFIER

    <识别名单> -> <标识符> |  <识别名单 ';' 标识符>

    constant_expressionà

          conditional_expression

     <恒表达式> -> <恒表达式>

    parameter_list à

           parameter_declaration

          | parameter_list ',' parameter_declaration

    <参数名单> -> <参数声明> | <参数名单 ';' 参数声明>


    parameter_declaration à

          declaration_specifiers  IDENTIFIER

     <参数声明>-><'说明符' '声明' '标识符'>

    compound_statement à

           '{' '}'

          | '{' statement_list '}'

          | '{' declaration_list statement_list '}'

     <复合语句>-> <'{' '}'> | <'{'语句列表'}'> | <'{'声明' '语句列表' '}'>

    declaration_list à

           declaration

          | declaration_list declaration

     <声明_列表> -> <识别符> | <识别名单 识别符>

    Declarationà

           init_declarator

          | init_declarator_list ',' init_declarator

     <识别符> -> <初始化标别符> |<初始化标识符 ',' 初始化标识符>

    init_declarator à

           declarator

          | declarator '=' initializer

     <初始化标识符> -> <标识符> | <标识符 '=' 初始化器>

    Initializer à

           assignment_expression

          | '{' initializer_list '}'

          | '{' initializer_list ',' '}'

     <初始化器> -> <赋值表达式> | <'{'  初始化列表 '}'> | <'{' 初始化列表 ',' '}'>

    initializer_list à

           initializer

          | initializer_list ',' initializer

     <初始化列表> -> <初始化>| <初始化列表 ',' 初始化器>

    statement_listà

          statement

          | statement_list statement

     <语句表> -> <语句> | <语句表 语句>

    Statement à

          | compound_statement

          | expression_statement

          | selection_statement

          | iteration_statement

          | jump_statement

     <语句> -> |<复合语句> |<表达式语句>|<选择语句>|<迭代语句>|<跳转语句>

    expression_statement à

          ';'

          | expression ';'

     <表达式语句> -> <';'> |<表达式 ';'>

    selection_statement

          : IF '(' expression ')' statement

          | IF '(' expression ')' statement ELSE statement

     <选择语句> :IF< '(' 表达式 ')' 语句> | IF <'(' 表达式 ')' 语句 ELSE 语句 >

    iteration_statementà

           WHILE '(' expression ')' statement

          | FOR '(' expression_statement expression_statement ')' statement

          | FOR '(' expression_statement expression_statement expression ')' statement

     <迭代语句> -> WHILE< '(' 表达式  ')' 语句 >| FOR '(' 表达语句 表达语句 ')' 语句 | FOR '(' 表达语句 表达语句 表达式 ')' 语句

    jump_statement

          | CONTINUE ';'

          | BREAK ';'

          | RETURN ';'

          | RETURN expression ';'

    expression

          : assignment_expression

          | expression ',' assignment_expression

    assignment_expression à

          conditional_expression

          | unary_expression assignment_operator assignment_expression

    conditional_expression à

           logical_or_expression

          | logical_or_expression '?' expression ':' conditional_expression

    logical_or_expression à

          logical_and_expression

          | logical_or_expression OR_OP logical_and_expression

    logical_and_expression

          : inclusive_or_expression

          | logical_and_expression AND_OP inclusive_or_expression

    inclusive_or_expressionà

          exclusive_or_expression

          | inclusive_or_expression '|' exclusive_or_expression

    exclusive_or_expression

          : and_expression

          | exclusive_or_expression '^' and_expression

    and_expression

          : equality_expression

          | and_expression '&' equality_expression

    equality_expression

          : relational_expression

          | equality_expression EQ_OP relational_expression

          | equality_expression NE_OP relational_expression

    relational_expression

          : shift_expression

          | relational_expression '<' shift_expression

          | relational_expression '>' shift_expression

          | relational_expression LE_OP shift_expression

          | relational_expression GE_OP shift_expression

    shift_expression

          : additive_expression

          | shift_expression LEFT_OP additive_expression

          | shift_expression RIGHT_OP additive_expression

    additive_expression

          : multiplicative_expression

          | additive_expression '+' multiplicative_expression

          | additive_expression '-' multiplicative_expression

    multiplicative_expression

          : cast_expression

          | multiplicative_expression '*' cast_expression

          | multiplicative_expression '/' cast_expression

          | multiplicative_expression '%' cast_expression

    cast_expression

          : unary_expression

          | '(' type_name ')' cast_expression

    unary_expression

          : postfix_expression

          | INC_OP unary_expression

          | DEC_OP unary_expression

          | unary_operator cast_expression

          | SIZEOF unary_expression

          | SIZEOF '(' type_name ')'

    postfix_expression à

          : primary_expression

          | postfix_expression '[' expression ']'

          | postfix_expression '(' ')'

          | postfix_expression '(' argument_expression_list ')'

          | postfix_expression '.' IDENTIFIER

          | postfix_expression PTR_OP IDENTIFIER

          | postfix_expression INC_OP

          | postfix_expression DEC_OP

    primary_expression à

          IDENTIFIER

          | CONSTANT

          | STRING_LITERAL

          | '(' expression ')'

    argument_expression_list

          : assignment_expression

          | argument_expression_list ',' assignment_expression

    unary_operator

          : '&'

          | '*'

          | '+'

          | '-'

          | '~'

          | '!'

    assignment_operator à

           '='

          | MUL_ASSIGN

          | DIV_ASSIGN

          | MOD_ASSIGN

          | ADD_ASSIGN

          | SUB_ASSIGN

          | LEFT_ASSIGN

          | RIGHT_ASSIGN

          | AND_ASSIGN

          | XOR_ASSIGN

          | OR_ASSIGN

    storage_class_specifier à

           TYPEDEF

          | EXTERN

          | STATIC

          | AUTO

          | REGISTER

    struct_or_union_specifier

          : struct_or_union IDENTIFIER '{' struct_declaration_list '}'

          | struct_or_union '{' struct_declaration_list '}'

          | struct_or_union IDENTIFIER

    struct_or_union

          : STRUCT

          | UNION

    struct_declaration_list

          : struct_declaration

          | struct_declaration_list struct_declaration

    struct_declaration

          : specifier_qualifier_list struct_declarator_list ';'

    specifier_qualifier_list à

           type_specifier specifier_qualifier_list

          | type_specifier

          | type_qualifier specifier_qualifier_list

          | type_qualifier

         

    struct_declarator_list à

           struct_declarator

          | struct_declarator_list ',' struct_declarator

         

    struct_declarator à

          : declarator

          | ':' constant_expression

          | declarator ':' constant_expression

         

    enum_specifier à

           ENUM '{' enumerator_list '}'

          | ENUM IDENTIFIER '{' enumerator_list '}'

          | ENUM IDENTIFIER

         

    enumerator_list à

           enumerator

          | enumerator_list ',' enumerator

         

    Enumerator à

           IDENTIFIER

          | IDENTIFIER '=' constant_expression

         

    type_qualifier à

           CONST

          | VOLATILE

         

    type_qualifier_list à

           type_qualifier

          | type_qualifier_list type_qualifier

         

    parameter_type_list à

           parameter_list

          | parameter_list ',' ELLIPSIS

         

    parameter_list à

          : parameter_declaration

          | parameter_list ',' parameter_declaration

         

    type_name à

           specifier_qualifier_list

          | specifier_qualifier_list abstract_declarator

         

    abstract_declarator à

           pointer

          | direct_abstract_declarator

          | pointer direct_abstract_declarator

         

    direct_abstract_declarator à

           '(' abstract_declarator ')'

          | '[' ']'

          | '[' constant_expression ']'

          | direct_abstract_declarator '[' ']'

          | direct_abstract_declarator '[' constant_expression ']'

          | '(' ')'

          | '(' parameter_type_list ')'

          | direct_abstract_declarator '(' ')'

          | direct_abstract_declarator '(' parameter_type_list ')'

         

    labeled_statement à

           IDENTIFIER ':' statement

          | CASE constant_expression ':' statement

          | DEFAULT ':' statement

         

  • 相关阅读:
    Java阶段测试题一
    HttpClient配置及运用(一)
    字符串数组及链表的应用:例题
    Java多线程
    String普通方法测试;可变参数
    Java连接mysql数据库
    JS练习
    foreach遍历、包装类、Object类
    Java多态总结
    类的关联,不同类属性的调用
  • 原文地址:https://www.cnblogs.com/wangjunjie123/p/4919923.html
Copyright © 2020-2023  润新知