source: EcnlProtoTool/trunk/asp3_dcre/tecsgen/tecslib/core/bnf.y.rb@ 270

# -*- coding: utf-8 -*-
#
#  TECS Generator
#      Generator for TOPPERS Embedded Component System
#  
#   Copyright (C) 2008-2016 by TOPPERS Project
#--
#   上記著作権者
は，以下の(1)～(4)ã®æ¡ä»¶ã‚’æº€ãŸã™å ´åˆã«é™ã‚Šï¼Œæœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§
#   ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
#   変・再é…
å¸ƒï¼ˆä»¥ä¸‹ï¼Œåˆ©ç”¨ã¨å‘¼ã¶ï¼‰ã™ã‚‹ã“とを無償で許諾する．
#   (1) æœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§ã‚¢ã‚’ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã®å½¢ã§åˆ©ç”¨ã™ã‚‹å ´åˆã«ã¯ï¼Œä¸Šè¨˜ã®è‘—ä½œ
#       権表示，この利用条件および下記の無保証規定が，そのままの形でソー
#       スコード中に含まれていること．
#   (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
#       用できる形で再é…
å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é…
å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
#       者
マニュアルなど）に，上記の著作権表示，この利用条件および下記
#       の無保証規定を掲載すること．
#   (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
#       用できない形で再é…
å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®ã„ずれかの条件を満たすこ
#       と．
#     (a) 再é…
å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€…
マニュアルなど）に，上記の著
#         作権表示，この利用条件および下記の無保証規定を掲載すること．
#     (b) 再é…
å¸ƒã®å½¢æ…
‹ã‚’，別に定める方法によって，TOPPERSプロジェクトに
#         å ±å‘Šã™ã‚‹ã“ã¨ï¼Ž
#   (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
#       害からも，上記著作権者
およびTOPPERSプロジェクトをå…
è²¬ã™ã‚‹ã“と．
#       また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
#       由に基づく請求からも，上記著作権者
およびTOPPERSプロジェクトを
#       å…
è²¬ã™ã‚‹ã“と．
#  
#   本ソフトウェアは，無保証で提供されているものである．上記著作権者
お
#   よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
#   に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
#   アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
#   ã®è²¬ä»»ã‚’è² ã‚ãªã„ï¼Ž
#  
#   $Id: bnf.y.rb 1011 2016-07-11 02:20:01Z coas-nagasima $
#++

class Generator
rule
# ãƒˆãƒƒãƒ—ãƒ¬ãƒ™ãƒ«ã®æ§‹æ–‡è¦ç´ ã¯component_description
all: component_description

# Expr
##########################  式  ##########################
# K&Rの文法(プログラミング言語C 第2版 付録)と一部異なる
# argument_expression_list(関数引数), assignment_expression(代å…
¥)がない
# 式の result は、すべてé…
åˆ—ã§ç¬¬ä¸€è¦ç´ ãŒè­˜åˆ¥ã‚·ãƒ³ãƒœãƒ«ã€ç¬¬äºŒè¦ç´ ä»¥ä¸‹ãŒå¼•æ•°

primary_expression
        : namespace_identifier
                { result = [ :IDENTIFIER, val[0] ] }     #1ok
        | TRUE
                { result = [ :BOOL_CONSTANT, true ] }
        | FALSE
                { result = [ :BOOL_CONSTANT, false ] }
        | INTEGER_CONSTANT
                { result = [ :INTEGER_CONSTANT, val[0] ] }
        | FLOATING_CONSTANT
                { result = [ :FLOATING_CONSTANT, val[0] ] }
        | OCTAL_CONSTANT
                { result = [ :OCTAL_CONSTANT, val[0] ] }
        | HEX_CONSTANT
                { result = [ :HEX_CONSTANT, val[0] ] }
        | CHARACTER_LITERAL
                { result = [ :CHARACTER_LITERAL, val[0] ] }
        | string_literal_list
                { result = [ :STRING_LITERAL_LIST, val[0] ] }
        | '(' expression ')'
                { result = [ :PARENTHESES, val[1].get_elements ] }

string_literal_list
        : STRING_LITERAL
        | string_literal_list STRING_LITERAL
                {
                        # 連接した文字列を1つの文字列にまとめる
                        str = "\"" + val[0].val.gsub( /\"(.*)\"/, "\\1" ) + val[1].val.gsub( /\"(.*)\"/, "\\1" ) + "\""
                        result = Token.new( str, val[0].file, val[0].lineno, val[0].col )
                }

# 関数呼び出しと後置インクリメント、デクリメント演算子がない
postfix_expression
        : primary_expression
        | postfix_expression '[' expression ']'
                { result = [ :OP_SUBSC, val[0], val[2] ] }
        | postfix_expression '.' IDENTIFIER
                { result = [ :OP_DOT, val[0], val[2] ] }
        | postfix_expression '->' IDENTIFIER
                { result = [ :OP_REF, val[0], val[2] ] }

# 前置インクリメント、デクリメント演算子がない
unary_expression
        : postfix_expression
        | unary_operator cast_expression
                { result = [ val[0], val[1] ] }
        | SIZEOF unary_expression
                { result = [ :OP_SIZEOF_EXPR, val[1] ] }
        | SIZEOF '(' type_name ')'
                { result = [ :OP_SIZEOF_TYPE, val[1] ] }

unary_operator
        : '&'   { result = :OP_U_AMP }
        | '*'   { result = :OP_U_ASTER }
        | '+'   { result = :OP_U_PLUS }
        | '-'   { result = :OP_U_MINUS }
        | '~'   { result = :OP_U_TILDE }
        | '!'   { result = :OP_U_EXCLAM }

cast_expression
        : unary_expression
        | '(' type_name ')' cast_expression
                {  result = [ :CAST, val[1], val[3] ] }

multiplicative_expression
        : cast_expression
        | multiplicative_expression '*' cast_expression
                { result = [ :OP_MULT, val[0], val[2] ]  }
        | multiplicative_expression '/' cast_expression
                { result = [ :OP_DIV, val[0], val[2] ]  }
        | multiplicative_expression '%' cast_expression
                { result = [ :OP_REMAIN, val[0], val[2] ]  }

additive_expression
        : multiplicative_expression
        | additive_expression '+' multiplicative_expression
                { result = [ :OP_ADD, val[0], val[2] ]  }
        | additive_expression '-' multiplicative_expression
                { result = [ :OP_SUB, val[0], val[2] ]  }

shift_expression
        : additive_expression
        | shift_expression '<<' additive_expression
                { result = [ :OP_LSFT, val[0], val[2] ]  }
        | shift_expression '>>' additive_expression
                { result = [ :OP_RSFT, val[0], val[2] ]  }

relational_expression
        : shift_expression
        | relational_expression '<' shift_expression
                { result = [ :OP_LT, val[0], val[2] ]  }
        | relational_expression '>' shift_expression
                { result = [ :OP_GT, val[0], val[2] ]  }
        | relational_expression '<=' shift_expression
                { result = [ :OP_LE, val[0], val[2] ]  }
        | relational_expression '>=' shift_expression
                { result = [ :OP_GE, val[0], val[2] ]  }

equality_expression
        : relational_expression
        | equality_expression '==' relational_expression
                { result = [ :OP_EQ, val[0], val[2] ]  }
        | equality_expression '!=' relational_expression
                { result = [ :OP_NE, val[0], val[2] ]  }

and_expression
        : equality_expression
        | and_expression '&' equality_expression
                { result = [ :OP_AND, val[0], val[2] ]  }

exclusive_or_expression
        : and_expression
        | exclusive_or_expression '^' and_expression
                { result = [ :OP_EOR, val[0], val[2] ]  }

inclusive_or_expression
        : exclusive_or_expression
        | inclusive_or_expression '|' exclusive_or_expression
                { result = [ :OP_OR, val[0], val[2] ]  }

logical_and_expression
        : inclusive_or_expression
        | logical_and_expression '&&' inclusive_or_expression
                { result = [ :OP_LAND, val[0], val[2] ]  }

logical_or_expression
        : logical_and_expression
        | logical_or_expression '||' logical_and_expression
                { result = [ :OP_LOR, val[0], val[2] ]  }

conditional_expression
        : logical_or_expression
        | logical_or_expression '?' expression ':' conditional_expression
                { result = [ :OP_CEX, val[0], val[2].get_elements, val[4] ]  }


# コンマ演算子が使えない
expression
        : conditional_expression
                {
                        result = Expression.new( val[0] )
                        # result.print
                }

constant_expression
        : conditional_expression
                {
                        result = Expression.new( val[0] )
                        # result.print

                        # res = result.eval_const( nil )
                        # if res then
                        #   puts "val: #{res}"
                        # else
                        #   puts "val: nil"
                        # end
                }



# Types
##########################  宣言  ##########################
# 宣言もK&Rと一部異なる

# declarationはセルの属性で使われる
# K&Rとの違い: storage classが指定できない、型が省略できない
declaration
        : type_specifier_qualifier_list init_declarator_list ';'
                {
                        val[1].each { |i|       # i: Decl
                                i.set_type( val[0] )
                        }
                        result = val[1]
                }

# declaration_specifiersは関数のパラメータで使われるが、
# type_specifier_qualifier_listで十分かもしれない
# Oyama
# const, volatile は単独で型にならないので変形
# const と volatile が同居
することはないので、繰返し指定できないようにした
# type_specifier も繰返し指定できる必
要はない (singed など単独で型にはならない)
declaration_specifiers
        : type_specifier
        | type_qualifier type_specifier
                {
                        val[1].set_qualifier( val[0] )
                        result = val[1]
                }

init_declarator_list
        : init_declarator
                { result = [val[0]] }
        | init_declarator_list ',' init_declarator
                { result << val[2] }

init_declarator
        : declarator
        | declarator '=' initializer
                { val[0].set_initializer( val[2] ) }

# INT8から下はK&Rにない
# Oyama
# signed, unsigned ã¯å˜ç‹¬ã§åž‹ã«ãªã‚‰ãªã„ã®ã§ã€æ§‹æ–‡è¦ç´ ã¨ã—ã¦åˆ†é›¢
type_specifier
        : VOID  { result = VoidType.new }
        | FLOAT32_T     { result = FloatType.new(32) }
        | DOUBLE64_T    { result = FloatType.new(64) }
        | struct_specifier
        | enum_specifier
        | TYPE_NAME     { result = DefinedType.new( val[0].val ) }
#        | IDENTIFIER   { result = DefinedType.new( val[0].val ) }   # reduce/reduce conflict が起こってしまう
        | sign_int_type
        | char_type
        | BOOL_T        { result = BoolType.new }
#        | BOOL {
#                       Generator.warning( "W5001 bool: obsolete type. use bool_t"  )
#                       result = BoolType.new
#               }
        | FLOAT {
                        Generator.warning( "W5002 float: obsolete type. use float32_t"  )
                        result = FloatType.new(32)
                }
        | DOUBLE {
                        Generator.warning( "W5003 double: obsolete type. use double64_t"  )
                        result = FloatType.new(64)
                }
        | DESCRIPTOR '(' namespace_identifier ')' {          # namespace_identifier: signature name
                        result = DescriptorType.new( val[2] )
                }

char_type
        : CHAR_T        { result = IntType.new( -1 ) }
        | SCHAR_T
                {
                        result = IntType.new( -1 )
                        result.set_sign( :SIGNED, true )
                }
        | UCHAR_T
                {
                        result = IntType.new( -1 )
                        result.set_sign( :UNSIGNED, true )
                }

int_type
        : CHAR  {
                        # Generator.warning( "W5004 char: obsolete type. use char_t"  )
                        result = IntType.new( -11 )
                }
        | SHORT { result = IntType.new( -2 ) }
        | INT           { result = IntType.new( -3 ) }
        | LONG  { result = IntType.new( -4 ) }
#        | INTPTR       { result = IntType.new( -5 ) }
#        | INT8 {
#                       Generator.warning( "W5005 int8: obsolete. use int8_t"  )
#                       result = IntType.new(  8 )
#               }
#        | INT16        {
#                       Generator.warning( "W5006 int16: obsolete. use int16_t"  )
#                       result = IntType.new( 16 )
#               }
#        | INT32        {
#                       Generator.warning( "W5007 int32: obsolete. use int32_t"  )
#                       result = IntType.new( 32 )
#               }
#        | INT64
#               {
#                       Generator.warning( "W5008 int64: obsolete. use int64_t"  )
#                       result = IntType.new( 64 )
#               }
#        | INT128
#               {
#                       Generator.warning( "W5009 int64: obsolete. use int64_t"  )
#                       result = IntType.new( 128 )
#               }
        | INT8_T        { result = IntType.new( 8 ) }
        | INT16_T       { result = IntType.new( 16 ) }
        | INT32_T       { result = IntType.new( 32 ) }
        | INT64_T       { result = IntType.new( 64 ) }
        | INT128_T      { result = IntType.new( 128 ) }
        | UINT8_T
                {
                        result = IntType.new( 8 )
                        result.set_sign( :UNSIGNED, true )
                }
        | UINT16_T
                {
                        result = IntType.new( 16 )
                        result.set_sign( :UNSIGNED, true )
                }
        | UINT32_T
                {
                        result = IntType.new( 32 )
                        result.set_sign( :UNSIGNED, true )
                }
        | UINT64_T
                {
                        result = IntType.new( 64 )
                        result.set_sign( :UNSIGNED, true )
                }
        | UINT128_T
                {
                        result = IntType.new( 128 )
                        result.set_sign( :UNSIGNED, true )
                }

sign    # TECS では signed, unsigned 単独では型にできない
        : SIGNED        { result = :SIGNED }
        | UNSIGNED      { result = :UNSIGNED }

# result[0] :CHAR などのトークン、result[1] :CONST, :VOLATILE など
sign_int_type
        : sign int_type
                {
                        val[1].set_sign( val[0] )
                        result = val[1]
                }
        | int_type

# K&Rのstruct_or_union_specifierに相当するが、unionは使えない
struct_specifier                # mikan
        : STRUCT struct_tag '{'
                { StructType.set_define( true )  }
           struct_declaration_list '}'
                {
                        StructType.end_of_parse
                        result = val[1]
                }
        | STRUCT
                {
                        result = StructType.new()
                        StructType.set_define( true )
                }
           '{' struct_declaration_list '}'
                {
                        StructType.end_of_parse
                        result = val[1]
                }
        | STRUCT struct_tag   # mikan struct_tag は namespace 対応が必
要
                {
                        StructType.set_define( false )
                        StructType.end_of_parse
                        result = val[1]
                }

struct_declaration_list
        : struct_declaration
        | struct_declaration_list struct_declaration

struct_tag:
        IDENTIFIER
                { result = StructType.new( val[0].val ) }

# ãƒã‚¤ãƒ³ã‚¿ä¿®é£¾å­ã‚’è¿½åŠ 
struct_declaration
        :                                type_specifier_qualifier_list struct_declarator_list ';'
                {
                        val[1].each { |i|       # i: Decl
                                i.set_type( val[0] )
                                i.set_kind( :MEMBER )
                                i.check
                                StructType.new_member( i )
                        }
                        result = val[1]
                }
        | spec_L pointer_specifier_list spec_R type_specifier_qualifier_list struct_declarator_list ';'
                {
                        val[4].each { |i|       # i: Decl
                                i.set_type( val[3] )
                                i.set_kind( :MEMBER )
                                i.set_specifier_list val[1]
                                i.check
                                StructType.new_member( i )
                        }
                        result = val[4]
                }

pointer_specifier_list
        : pointer_specifier                               { result = [ val[0] ] }
        | pointer_specifier_list ',' pointer_specifier    { result <<  val[2] }

pointer_specifier
        : STRING                                { result = [:STRING,-1] }
        | STRING   '(' expression ')'   { result = [:STRING,val[2]] }
        | SIZE_IS  '(' expression ')'   { result = [:SIZE_IS,val[2]] }
        | COUNT_IS '(' expression ')'   { result = [:COUNT_IS,val[2]] }


# K&Rのspecifier_qualifier_listと同じ
# 名前がまぎらわしかったのでtype_を付けた
type_specifier_qualifier_list
# Oyama type_specifier を繰り返して指定することはなくなった (sign_int_type としたため）
#        : type_specifier type_specifier_qualifier_list
        : type_specifier
        | type_qualifier type_specifier_qualifier_list
                {
                        val[1].set_qualifier( val[0] )
                        result = val[1]
                }
# mikan Oyama type_qualifier だけでは型指定にならない : 構文エラーとするより、意味エラーとした方が親切
#        | type_qualifier


struct_declarator_list
        : struct_declarator
                { result = [ val[0] ] }
        | struct_declarator_list ',' struct_declarator
                { result << val[2] }

# ビットフィールドは使えない
struct_declarator
        : declarator

# enumã®ç¨®é¡žã‚’è¿½åŠ 
enum_specifier          # mikan
        : enum_type            '{' enumerator_list '}'
        | enum_type IDENTIFIER '{' enumerator_list '}'
        | enum_type IDENTIFIER

enum_type
        : ENUM  { result = EnumType.new( -1 ) }
        | ENUM8 { result = EnumType.new( 8 ) }
        | ENUM16        { result = EnumType.new( 16 ) }
        | ENUM32        { result = EnumType.new( 32 ) }
        | ENUM64        { result = EnumType.new( 64 ) }
        | ENUM128       { result = EnumType.new( 128 ) }

enumerator_list
        : enumerator
        | enumerator_list ',' enumerator

enumerator
        : IDENTIFIER
        | IDENTIFIER '=' constant_expression

type_qualifier
        : CONST { result = :CONST }
        | VOLATILE      { result = :VOLATILE }

declarator
        : pointer direct_declarator
                {
                        val[1].set_type( val[0] )
                        result = val[1]
                }
        | direct_declarator

direct_declarator               # mikan
        : IDENTIFIER
                { result = Decl.new( val[0].val ) }
        | '(' declarator ')'
                { result = val[1] }
        | direct_declarator '[' constant_expression ']'
                {
                        val[0].set_type( ArrayType.new( val[2] ) )
                        result = val[0]
                }
        | direct_declarator '[' ']'
                {
                        val[0].set_type( ArrayType.new )
                        result = val[0]
                }
        | direct_declarator '(' parameter_type_list ')'
                {
                        val[0].set_type( FuncType.new( val[2] ) )
                        result = val[0]
                }
#        | direct_declarator '(' identifier_list ')'  # これは何のために必
要？ 060211
        | direct_declarator '(' ')'
                {
                        Generator.warning( "W5010 need 'void' for no parameter"  )
                        val[0].set_type( FuncType.new )
                        result = val[0]
                }

pointer
        : '*'
                { result = PtrType.new }
        | '*' type_qualifier
                {
                        result = PtrType.new
                        result.set_qualifier( val[1] )
                }
        | '*' pointer
                {
                        val[1].set_type(PtrType.new)
                        result = val[1]
                }
        | '*' type_qualifier pointer
                {
                        ptrtype = PtrType.new
                        ptrtype.set_qualifier( val[1] )
                        val[2].set_type( ptrtype )
                        result = val[2]
                }


parameter_type_list
        : parameter_list
        | parameter_list ',' '...'
                # mikan 可変長パラメータ

parameter_list
        : parameter_declaration
                { result = ParamList.new( val[0] ) }
        | parameter_list ',' parameter_declaration
                {
                        val[0].add_param( val[2] )
                        # result = val[0] 不要
                }


# ãƒ‘ãƒ©ãƒ¡ãƒ¼ã‚¿ä¿®é£¾å­ã‚’è¿½åŠ 
parameter_declaration
#        : spec_L parameter_specifier_list spec_R declaration_specifiers declarator
        : parameter_specifier_list_bracket declaration_specifiers  declarator
                {
                        val[2].set_kind( :PARAMETER )
                        paramdecl = ParamDecl.new( val[2], val[1], val[0] )
                        val[2].check
                        result = paramdecl
                }

        # 以下はエラーとする
        | declaration_specifiers declarator # parameter_specifier なしは扱わない
                {
                        Generator.error( "G1001 need specifier for \'$1\'" , val[1].get_name )
                        result = nil
                }
        | declaration_specifiers        # 仮引数なしは、とりあえず扱わない 060210
                {
                        unless val[0].instance_of?( VoidType ) then
                                Generator.error( "G1002 need parameter name"  )
                        end
                        result = nil
                }
#        | '[' parameter_specifier_list ']' declaration_specifiers # 同 060210
        | parameter_specifier_list_bracket declaration_specifiers # 同 060210
                {
                        unless val[1].instance_of?( VoidType ) then
                                Generator.error( "G1003 need parameter name"  )
                        end
                        result = nil
                }

parameter_specifier_list_bracket
        :  spec_L parameter_specifier_list spec_R { result = val[1] }
#        :  '[' parameter_specifier_list  ']'  { result = val[1] }

parameter_specifier_list
        : parameter_specifier   { result = val[0] }
        | parameter_specifier_list ',' parameter_specifier
                { result = result + val[2] }

parameter_specifier
        : IN                                    { result = [ [:IN]  ] }
        | OUT                                   { result = [ [:OUT] ] }
        | INOUT                                 { result = [ [:INOUT] ] }
        | SEND     '(' namespace_identifier ')' { result = [ [:SEND,   val[2]] ] }   #1ok allocator
        | RECEIVE  '(' namespace_identifier ')' { result = [ [:RECEIVE,val[2]] ] }   #1ok allocator
        | STRING                                { result = [ [:STRING,nil] ] }
        | STRING   '(' expression ')'   { result = [ [:STRING,  val[2]] ] }
        | SIZE_IS  '(' expression ')'   { result = [ [:SIZE_IS, val[2]] ] }
        | SIZE_IS  '(' expression ',' constant_expression ')'
                {
                        result = [ [:SIZE_IS,val[2]], [:MAX_IS, val[4]] ]
                }
        | COUNT_IS '(' expression ')'   { result = [ [:COUNT_IS,val[2]] ] }
        | NULLABLE              { result = [ [:NULLABLE] ] }

type_name
        : type_specifier_qualifier_list
        | type_specifier_qualifier_list abstract_declarator
                {
                        if val[1] then
                                val[1].set_type( val[0] )
                                result = val[1]
                        else
                                # エラー：仮で val[0] を返す
                                result = val[0]
                        end
                }
                # mikan abstract_declarator が pointer 以外ではうまく動かない、とりあえず '*' CAST のみ救った

abstract_declarator             # mikan
        : pointer
        | direct_abstract_declarator
        | pointer direct_abstract_declarator

direct_abstract_declarator
        : '(' abstract_declarator ')'
                { result = val[1] }  # 関数ポインタ型を救う
        | '[' ']'
                {
                        Generator.error( "G1004 impossible array type"  )
                        result = nil
                }
        | '[' constant_expression ']'
                {
                        Generator.error( "G1005 impossible array type"  )
                        result = nil
                }
        | direct_abstract_declarator '[' ']'
                {
                        Generator.error( "G1006 impossible array type"  )
                        result = nil
                }
        | direct_abstract_declarator '[' constant_expression ']'
                {
                        Generator.error( "G1007 impossible array type"  )
                        result = nil
                }
        | '(' ')'
                {
                        Generator.error( "G1008 impossible function type"  )
                        result = nil
                }
        | '(' parameter_type_list ')'
        | direct_abstract_declarator '(' ')'
                {
                        Generator.warning( "W5011 need 'void' for no parameter"  )
                        val[0].set_type( FuncType.new )
                        result = val[0]
                }
        | direct_abstract_declarator '(' parameter_type_list ')'
                {
                        val[0].set_type( FuncType.new( val[2] ) )
                        result = val[0]
                }

# assignment_expressionをconstant_expressionに変更
initializer                     # mikan
        : constant_expression
                { result = val[0] }
        | '{' initializer_list '}'
                { result = val[1] }
        | '{' initializer_list ',' '}'
                { result = val[1] }
#        | C_EXP '(' STRING_LITERAL ')'
        | C_EXP '(' string_literal_list ')'
                { result = C_EXP.new( val[2] ) }

initializer_list
        : initializer
                {
                        result = [ val[0] ]
                }
        | initializer_list ',' initializer
                {
                        val[0] << val[2]
                        result = val[0]
                }


##########################  ここからはCDL独自  ##########################

#トップレベルの構文規則
#コンポーネント記述
component_description
        : component_description specified_statement
        | component_description location_information
        | 

specified_statement
        : statement
        | spec_L statement_specifier_list spec_R statement
                {
                        obj = val[3]
                        if obj.kind_of?( Cell ) || obj.kind_of?( Signature ) || obj.kind_of?( Celltype ) || obj.kind_of?( CompositeCelltype )then
                                # cell, signature 以外は、指定子を置けない
                        else
              Generator.get_statement_specifier   # クリア
              Generator.error( "G1009 unexpected specifier"  )
                        end
                }
                # これと同じ記述が composite_celltype にもある

statement
        : typedef
        | const_statement
        | namespace
        | signature
        | celltype
        | cell
        | composite_celltype
        | enum_specifier ';'
        | struct_specifier ';'
        | region
        | import
        | import_C
        | signature_plugin
        | error   # エラー回復ポイント

        
statement_specifier_list
        : statement_specifier
                { Generator.add_statement_specifier val[0]      }
        | statement_specifier_list ',' statement_specifier
                { Generator.add_statement_specifier val[2] }

statement_specifier
        : ALLOCATOR '(' alloc_list ')'                       # cell
                { result = [ :ALLOCATOR, val[2] ] }
        | CALLBACK                                           # signature
                { result = [ :CALLBACK ] }
        | CONTEXT '(' string_literal_list ')'                # signature
                { result = [ :CONTEXT, val[2].val ] }
        | DEVIATE                                            # signature
                { result = [ :DEVIATE ] }
        | ID '(' constant_expression ')'                     # cell
                { result = [ :ID, val[2] ] }
        | PROTOTYPE                                          # cell
                { result = [ :PROTOTYPE ] }
        | RESTRICT  '(' restrict_list ')'                    # cell
                { result = [ :RESTRICT, val[2] ] }
        | SINGLETON  { result = [:SINGLETON] }               # celltype, composite
        | IDX_IS_ID  { result = [:IDX_IS_ID] }               # celltype, composite (composite: no-effective)
        | ACTIVE     { result = [:ACTIVE] }                  # celltype, composite
        | GENERATE '(' plugin_name ',' plugin_arg  ')'       # celltype, cell
                { result = [:GENERATE, val[2].val, val[4].val] }

alloc_list
        : alloc                 { result = [ val[0] ] }
        | alloc_list ',' alloc  { result << val[2] }

alloc
        : IDENTIFIER '.' IDENTIFIER '.' IDENTIFIER '=' initializer
                {  result = [ :NORMAL_ALLOC, val[0], nil, val[2], val[4], val[6] ] }
        | IDENTIFIER '[' constant_expression ']' '.' IDENTIFIER '.' IDENTIFIER '=' initializer
                {  result = [ :NORMAL_ALLOC, val[0], val[2], val[5], val[7], val[9] ] }
# mikan 将来的な拡張 ('*' でまとめて指定可能とする)
#        | IDENTIFIER '.' IDENTIFIER '.' '*'        '=' initializer
#               {  result = [ val[0], val[ ], val[ ], val[ ] ] }
#        | IDENTIFIER '.' '*' '.' '*'               '=' initializer
#               {  result = [ val[0], val[ ], val[ ], val[ ] ] }

restrict_list
        : restrict
                {       result = [val[0]]               }
        | restrict_list ',' restrict
                {       result << val[2]                }

restrict
        : port_name '=' '{' region_name_list '}'
                {       result = [ val[0].val, nil, val[3] ]            }
        | port_name '.' IDENTIFIER '=' '{' region_name_list '}'
                {       result = [ val[0].val, val[2].val, val[5] ]             }

region_name_list
        : IDENTIFIER
                {       result = [val[0].val]           }
        | region_name_list ',' IDENTIFIER
                {       result << val[2].val            }

const_statement
        : declaration   # 定数定義
                {
                        val[0].each { |decl|
                                decl.set_kind( :CONSTANT )
                                Namespace.new_const_decl( decl )
                                decl.check
                        }
                }

import_C
        : IMPORT_C '(' STRING_LITERAL ')' ';'
                {
                        @@import_C = true
                        Import_C.new( val[2] )
                        @@import_C = false
                }
        | IMPORT_C '(' STRING_LITERAL ',' STRING_LITERAL ')' ';'
                {
                        @@import_C = true
                        Import_C.new( val[2], val[4] )
                        @@import_C = false
                }

import
        : IMPORT '(' STRING_LITERAL ')' ';'
                { Import.new( val[2] ) }
        | IMPORT '(' AB_STRING_LITERAL ')' ';'
                { Import.new( val[2], true ) }

signature_plugin
#        : GENERATE '(' plugin_name ',' namespace_identifier ',' STRING_LITERAL ')' ';'  #1ok signature plugin
        : GENERATE '(' plugin_name ',' namespace_identifier ',' plugin_arg ')' ';'  #1ok signature plugin
                { Generate.new( val[2].val, val[4], val[6] ) }

typedef
        : TYPEDEF type_specifier_qualifier_list declarator_list ';'
                {
                        val[2].each{ |i|       # i:Decl
                                i.set_kind( :TYPEDEF )
                }
                        Typedef.new_decl_list( val[1], val[2] )
                        val[2].each{ |i|       # i:Decl
                                i.check
                        }
                }
        | TYPEDEF '[' typedef_specifier ']' type_specifier_qualifier_list declarator_list ';'
                {
                        val[5].each{ |i|       # i:Decl
                                i.set_kind( :TYPEDEF )
                        }
                        Typedef.new_decl_list( val[4], val[5] )
                        val[5].each{ |i|       # i:Decl
                                i.check
                        }
                }
                # mikan   typedef_specifier 未処置


typedef_specifier
        : STRING
        | STRING '(' expression ')'

declarator_list
        : declarator
                { result = [ val[0] ] }
        | declarator_list ',' declarator
                { result << val[2] }

namespace
        : NAMESPACE namespace_name '{' statement_list '}' ';'
                {val[1].end_of_parse}

namespace_name
        : IDENTIFIER
                {result = Namespace.new(val[0].val)}
                # namespace インスタンスに statement を記憶させるためここで生成

statement_list
        : specified_statement
        | statement_list specified_statement

namespace_identifier
        : IDENTIFIER            { result = NamespacePath.new( val[0].val, false ) }
        | '::' IDENTIFIER       { result = NamespacePath.new( val[1].val, true ) }
        | namespace_identifier '::' IDENTIFIER
                { result = val[0].append!( val[2].val ) }

#シグニチャ
signature
        : SIGNATURE signature_name '{' function_head_list '}' ';'
                { result = val[1].end_of_parse( val[3] ) }

signature_name
        : IDENTIFIER
                {result = Signature.new( val[0].val ) }

function_head_list     # result:  function_head のé…
åˆ—
#        : function_head
#               { result = NamedList.new( val[0], "function" ) }
        :
                { result = NamedList.new( nil, "function" ) }
        | function_head_list function_head
                { result = val[0].add_item( val[1] ) }

function_head
        :               type_specifier_qualifier_list declarator ';'
                {
                        # val[1]: Decl
                        if val[1].is_function? then
                                result = FuncHead.new( val[1], val[0], false )
                                val[1].set_kind :FUNCHEAD
                                val[1].check
                        else
                                # mikan 関数のé…
åˆ—も以下のメッセージになる
                                Generator.error( "G1010 Not function"  )
                                result = nil
                        end
                }
        | spec_L ONEWAY spec_R type_specifier_qualifier_list declarator ';'
                {
                        if val[4].is_function? then
                                result = FuncHead.new( val[4], val[3], true )
                        else
                                Generator.error( "G1011 Not function"  )
                                result = nil
                        end
                }


#セルタイプ
celltype
        : CELLTYPE celltype_name '{' celltype_statement_list '}' ';'
                {
                        val[1].end_of_parse
                        result = val[1]
                }

celltype_name
        : IDENTIFIER
                { result = Celltype.new(val[0].val) }

celltype_statement_list
        : specified_celltype_statement
        | celltype_statement_list specified_celltype_statement

specified_celltype_statement
        : celltype_statement
                {
                        if val[0].kind_of? Port then
                                Celltype.new_port( val[0] )
                        end
                }
        | spec_L celltype_statement_specifier_list spec_R celltype_statement
                {
                        if val[3].kind_of? Port then
                                val[3].set_specifier val[1]  # è¨­å®šé †åºã‚ã‚Š
                                Celltype.new_port( val[3] )
                        else
                                # Port 以外では指定子はエラー
                                Generator.error( "G1012 $1 : cannot put specifier here" , val[1] )
                        end
                }

celltype_statement
        : port
        | attribute
        | var
        | require
        | factory
#        | error       # エラー回復ポイント  (#513 無限ループに陥るケースがあるので、ここでのエラー回復は取りやめ)

celltype_statement_specifier_list
        : celltype_statement_specifier
                { result = [ val[0] ] }
        | celltype_statement_specifier_list ',' celltype_statement_specifier
                { result << val[2] }

celltype_statement_specifier
        : INLINE { result = [ :INLINE ] }
        | ALLOCATOR '(' alloc_list2 ')'    { result = [ :ALLOCATOR, val[2] ] }
        | OPTIONAL { result = [ :OPTIONAL ] }
        | REF_DESC { result = [ :REF_DESC ] }
        | DYNAMIC { result = [ :DYNAMIC ] }
        | OMIT { result = [ :OMIT ] }

alloc_list2
        : alloc2                        { result = [ val[0] ] }    # 受け口のアロケータ指定
        | alloc                         { result = [ val[0] ] }    # 内
部セルのアロケータ指定
        | alloc_list2 ',' alloc2        { result << val[2] }
        | alloc_list2 ',' alloc         { result << val[2] }

alloc2
        : IDENTIFIER '.' IDENTIFIER '=' initializer    # 内
部アロケータ (デバドラ向きアロケータ)指定
                {  result = [ :INTERNAL_ALLOC, val[0].val, val[2].val, val[4] ] }
        | IDENTIFIER '.' IDENTIFIER '<=' initializer   # 多段リレーモデル向きアロケータ指定
                {  result = [ :RELAY_ALLOC, val[0].val, val[2].val, val[4] ] }


#呼び口、受け口
port
        : port_type namespace_signature_name port_name ';'
                { result = Port.new( val[2].val, val[1], val[0] ) }
        | port_type namespace_signature_name port_name '[' ']' ';'
                { result = Port.new( val[2].val, val[1], val[0], "[]" ) }
        | port_type namespace_signature_name port_name '[' array_size ']' ';'
                { result = Port.new(val[2].val, val[1], val[0], val[4]) }
        | port_type namespace_signature_name port_name '<=' namespace_identifier '.' IDENTIFIER ';'    #1ok reverse require
                { result = Port.new( val[2].val, val[1], val[0], nil, val[4], val[ 6 ].val ) }

port_type
        : CALL  { result = :CALL }
        | ENTRY { result = :ENTRY }

namespace_signature_name
        : namespace_identifier  #1ok
                { result = val[0] }

port_name
        : IDENTIFIER

array_size
        : constant_expression


#属性
attribute
        : ATTRIBUTE '{' attribute_declaration_list '}' ';'
                { result = nil }

attribute_declaration_list
        : attribute_declaration
                { Celltype.new_attribute( val[0] ) }
        | attribute_declaration_list attribute_declaration
                { Celltype.new_attribute( val[1] ) }


attribute_declaration
        :                             declaration
                {
                        val[0].each{ |i|       # i:Decl
                                i.set_kind( :ATTRIBUTE )
                                i.check
                        }
                        result = val[0]
                }
        | spec_L attribute_specifier spec_R declaration
                {
                        val[3].each{ |i|       # i:Decl
                                i.set_kind( :ATTRIBUTE )   # è¨­å®šé †åºã‚ã‚Š
                                i.set_specifier_list( [val[1]] )
                                i.check
                        }
                        result = val[3]
                }

attribute_specifier
        : OMIT     { result = [:OMIT] }
        | SIZE_IS  '(' expression ')'   { result = [:SIZE_IS,val[2]] }
        | CHOICE '=' '{' choice_list '}' {  result = [:CHOICE,val[3]] }

choice_list
        : choice_list ',' choice_element {  result << val[2] }
        | choice_element                 {  result = [ val[0] ] }

choice_element
        : STRING_LITERAL

#内
部変数
var
        : VAR '{' var_declaration_list '}' ';'
                { result = nil }

var_declaration_list
        : var_declaration
                { Celltype.new_var( val[0] ) }
        | var_declaration_list var_declaration
                { Celltype.new_var( val[1] ) }

var_declaration
        : declaration
                {
                        val[0].each{ |i|       # i:Decl
                                i.set_kind( :VAR )
                                i.check
                        }
                }
        | spec_L var_specifier spec_R declaration
                {
                        val[3].each{ |i|       # i:Decl
                                i.set_kind( :VAR )   # è¨­å®šé †åºã‚ã‚Š
                                i.set_specifier_list( [val[1]] )
                                i.check
                        }
                        result = val[3]
                }

var_specifier
        : SIZE_IS  '(' expression ')'   { result = [:SIZE_IS,val[2]] }

# リクワイア
require
        : REQUIRE namespace_identifier '.' IDENTIFIER';'                            # mikan namespace #1
                {
                        Celltype.new_require( val[1], val[3] )
                }
        | REQUIRE IDENTIFIER '=' namespace_identifier '.' IDENTIFIER';'             #1
                {
                        Celltype.new_require( val[3], val[5], val[1].val )
                }

#ファクトリ
factory
        : factory_head '{' factory_function_list '}' ';'

factory_head
        : FACTORY     { Factory.set_f_celltype( false ) }
        | CTFACTORY   { Factory.set_f_celltype( true ) }

factory_function_list
        :                                         # 空
        | factory_function_list factory_function

factory_function
        : factory_function_name '(' constant_expression ',' constant_expression  ')' ';'
                { Factory.new( val[0].val, val[2], val[4], nil    ) }
        | factory_function_name '(' constant_expression ',' constant_expression ',' arg_list ')' ';'
                { Factory.new( val[0].val, val[2], val[4], val[6] ) }

factory_function_name
        : IDENTIFIER

arg_list     # factory の write 関数の第三引数以降
        : IDENTIFIER
                { result = [ [ :IDENTIFIER, val[0].val ] ] }
        | arg_list ',' IDENTIFIER
                { result << [ :IDENTIFIER, val[2].val ] }
        | STRING_LITERAL
                { result = [ [ :STRING_LITERAL, val[0].val ] ] }
        | arg_list ',' STRING_LITERAL
                { result << [ :STRING_LITERAL, val[2].val ] }

#セル生成
cell
        : CELL namespace_celltype_name cell_name '{'
                { Cell.new_def }
          join_list '}' ';'
                { result = Cell.end_of_parse true }
        | CELL namespace_celltype_name cell_name ';'   # oyama プロトタイプ宣言
                        { result = Cell.end_of_parse false }

namespace_celltype_name
        : namespace_identifier
                { result = Cell.new(val[0]) }

cell_name
        : IDENTIFIER
                { result = Cell.set_name(val[0].val) }

join_list
        :   # 空行  061007
        | join_list specified_join
        | join_list reverse_join

specified_join
        :  spec_L join_specifier_list spec_R join
                { val[3].set_specifier_list( val[1] )  }
        |  join
                { val[0].set_specifier_list( [] ) }

join_specifier_list
        : join_specifier_list ',' join_specifier
                { result << val[2] }
        | join_specifier
                { result = [val[0]] }

join_specifier
        : THROUGH '(' plugin_name ',' plugin_arg ')'
                { result = [ :THROUGH, val[2], val[4] ] }

plugin_name
        : IDENTIFIER   { result = val[0] }

plugin_arg
        : string_literal_list

join
#        : cae_name                     '=' expression ';'
#               {
#                       result = Join.new( val[0].val, nil, val[2] )
#                       Cell.new_join( result, true )
#               }
#        | cae_name '[' ']'             '=' expression ';'
        : cae_name '[' ']'             '=' expression ';'
                {
                        result = Join.new( val[0].val,  -1, val[4] )
                        Cell.new_join( result, true )
                 }
        | cae_name '[' array_index ']' '=' expression ';'
                {
                        result = Join.new( val[0].val, val[2], val[5] )
                        Cell.new_join( result, true )
                }
        | cae_name '=' initializer ';'     # 初期化子： '{', '}' も可
                {
                        result = Join.new( val[0].val, nil, val[2] )
                        Cell.new_join( result, true )
                }
        | cae_name '=' COMPOSITE '.' IDENTIFIER ';'
                {
                        result = Join.new( val[0].val, nil, [ :COMPOSITE, val[4] ] )
                        Cell.new_join( result, true )
                }

cae_name #  cae: callport, attribute, entryport
        : IDENTIFIER

reverse_join
        # non-array <= non-array
        : cae_name '<=' namespace_identifier '.' IDENTIFIER ';'
                {
                        rj = ReverseJoin.new( val[0].val, nil, val[2], val[4].val )
                        Cell.new_reverse_join( rj )
                }
        # non-array <= array
        | cae_name '<=' namespace_identifier '.' IDENTIFIER '[' expression ']' ';'
                {
                        rj = ReverseJoin.new( val[0].val, nil, val[2], val[4].val, val[6] )
                        Cell.new_reverse_join( rj )
                }
        # array <= non-array
        | cae_name '[' array_index ']' '<=' namespace_identifier '.' IDENTIFIER ';'
                {
                        rj = ReverseJoin.new( val[0].val, val[2], val[5], val[7].val )
                        Cell.new_reverse_join( rj )
                }
        # array <= array
        | cae_name '[' array_index ']' '<=' namespace_identifier '.' IDENTIFIER '[' expression ']' ';'
                {
                        rj = ReverseJoin.new( val[0].val, val[2], val[5], val[7].val, val[9] )
                        Cell.new_reverse_join( rj )
                }


array_index
        : constant_expression

#複合種
composite_celltype
        : COMPOSITE composite_celltype_name '{' composite_celltype_statement_list '}' ';'
                {
                        CompositeCelltype.end_of_parse
                        result = val[1]
                }

composite_celltype_name
        : IDENTIFIER
                { result = CompositeCelltype.new(val[0].val) }

composite_celltype_statement_list
        : specified_composite_celltype_statement
        | composite_celltype_statement_list specified_composite_celltype_statement

specified_composite_celltype_statement
        : composite_celltype_statement
                {
                        if val[0].kind_of?( Port ) then
                                CompositeCelltype.new_port( val[0] )   # 遅
延して登録
                        end
                }
        | spec_L composite_celltype_statement_specifier_list spec_R composite_celltype_statement
                {
                        if val[3].kind_of?( Port ) then
                                # port 以外 val[3] に有効な値がå…
¥ã£ã¦ã„ないので、以下のメソッドを適用できない
                                # 現状 port, cell 以外は指定子を受け付けない
                                # （しかし将来他の文も指定子を受け付ける可能性があるので、この位置に記述する）
                                val[3].set_specifier( Generator.get_statement_specifier )
                                CompositeCelltype.new_port( val[3] )   # 遅
延して登録 (set_specifier 後)
                        elsif val[3].kind_of?( Cell ) then
                                # Cell.end_of_parse にて設定
                        else
              Generator.get_statement_specifier   # クリア
              Generator.error( "G1013 unexpected specifier"  )
                        end
                }

composite_celltype_statement
        : composite_port
        | composite_attribute
        | internal_cell
        | export_join
#        | error       # エラー回復ポイント  (#513 無限ループに陥るケースがあるので、ここでのエラー回復は取りやめ)

composite_celltype_statement_specifier_list
        : composite_celltype_statement_specifier
                {
                        Generator.add_statement_specifier val[0]
                        result = [ val[0] ]
                }

composite_celltype_statement_specifier
        : ALLOCATOR '(' alloc_list2 ')'         { result = [ :ALLOCATOR, val[2] ] }
        | OMIT  { result = [ :OMIT ] }
        | OPTIONAL      { result = [ :OPTIONAL ] }
        | REF_DESC      { result = [ :REF_DESC ] }
        | DYNAMIC       { result = [ :DYNAMIC ] }

composite_port
        : port
                {
                        # CompositeCelltype.new_port( val[0] )
                        result = val[0]
                }

#属性
composite_attribute
        : ATTRIBUTE '{' composite_attribute_declaration_list '}' ';'
                { result = nil }

composite_attribute_declaration_list
        : attribute_declaration
                { CompositeCelltype.new_attribute( val[0] ) }
        | composite_attribute_declaration_list attribute_declaration
                { CompositeCelltype.new_attribute( val[1] ) }

internal_cell
        : CELL internal_namespace_celltype_name
             internal_cell_name '{'
                { Cell.new_def }
             internal_join_list '}' ';'
                { result = Cell.end_of_parse true }
        | CELL internal_namespace_celltype_name internal_cell_name ';'
                { result = Cell.end_of_parse false }


internal_namespace_celltype_name
        : namespace_identifier
                { Cell.new(val[0],true) }

internal_cell_name
        : IDENTIFIER
                { Cell.set_name(val[0].val) }


internal_join_list
        :   # 空行  061007
        | internal_join_list specified_join
        | internal_join_list external_join

external_join  # cell 内
に記述する呼び口の外部結合
        : internal_cell_elem_name '=>' COMPOSITE '.' export_name ';'
                {       Cell.external_join( val[0].val, val[4].val, true )      }
        | internal_cell_elem_name '=>' export_name ';'
                {       Cell.external_join( val[0].val, val[2].val, false )     }
        # 以前の文法では、呼び口側も cell の外に記述していた
        # その時の実装
を

export_join    # cell 外に記述する受け口の外部結合
        : export_name '=>' internal_ref_cell_name '.' internal_cell_elem_name ';'
                {
                        CompositeCelltype.new_join( val[0].val,
                                                val[2].val, val[4].val, :ENTRY )
                }
        | COMPOSITE '.' export_name '=>' internal_ref_cell_name '.' internal_cell_elem_name ';'
                {
                        CompositeCelltype.new_join( val[2].val,
                                                val[4].val, val[6].val, :ENTRY )
                }

export_name
        : IDENTIFIER

internal_ref_cell_name
        : IDENTIFIER

internal_cell_elem_name
        : IDENTIFIER

# リージョン
region
        : spec_L region_specifier_list spec_R REGION region_name '{'  region_statement '}' ';'
                { Region.end_of_parse }
        |                  REGION region_name '{'  region_statement '}' ';'
                { Region.end_of_parse }


region_specifier_list
        : region_specifier
        | region_specifier_list ',' region_specifier

region_specifier
        : IN_THROUGH '(' plugin_name ',' plugin_arg ')'
                { Region.new_in_through( val[2].val, val[4].val ) }
        | IN_THROUGH '(' ')'   # in 許可
                { Region.new_in_through }
        | OUT_THROUGH '(' plugin_name ',' plugin_arg ')'
                { Region.new_out_through( val[2].val, val[4].val ) }
        | OUT_THROUGH '(' ')'  # out 許可
                { Region.new_out_through() }
        | TO_THROUGH '(' namespace_region_name ',' plugin_name ',' plugin_arg ')'
                { Region.new_to_through( val[2], val[4].val, val[6].val ) }
        | TO_THROUGH '('namespace_region_name ')'  # to 許可
                { Region.new_to_through( val[2], nil, nil ) }
        | NODE
                { Region.set_type( :NODE ) }
        | LINKUNIT
                { Region.set_type( :LINKUNIT ) }
        | DOMAIN '(' IDENTIFIER ',' STRING_LITERAL ')'
                { Region.set_domain( val[2].val, val[4] ) }
        | CLASS '(' IDENTIFIER ')'
                { Region.set_type( :CLASS, val[2].val ) }

region_name
        : IDENTIFIER
                { result = Region.new( val[0].val ) }

region_statement
        :
        | region_statement region_cell
        | region_statement region

region_cell
        : cell
        | spec_L statement_specifier_list spec_R cell
                {
                        obj = val[3]
                        if obj.kind_of?( Cell ) then
                        else
              Generator.get_statement_specifier   # クリア
              Generator.error( "G9999 unexpected specifier"  )
                        end
                }
#        | spec_L region_cell_specifier_list spec_R cell

# region_cell_specifier_list
#         : region_cell_specifier
#               { Generator.add_statement_specifier val[0] }
#         | region_cell_specifier_list region_cell_specifier
#               { Generator.add_statement_specifier val[2] }

# region_cell_specifier
#         : ALLOCATOR '(' alloc_list ')'
#               { result = [ :ALLOCATOR, val[2] ] }


namespace_region_name
         : :IDENTIFIER
                { result = [ val[0].val ] }  # mikan é…
åˆ—である必
要はない
#        : namespace_identifier

# 指定子の括弧 (in, out などのキーワード切り替えのため分離)
spec_L
        : '['  { set_in_specifier }
spec_R
        : ']'  { unset_in_specifier }

# location information
location_information
        :  __LOCATION_INFORMATION__ '{'  cell_location_join_location_list '}'

cell_location_join_location_list
        : cell_location_join_location_list cell_location
        | cell_location_join_location_list join_location
        |

cell_location
        : __CELL__ namespace_identifier '(' constant_expression ',' constant_expression ','  constant_expression ','  constant_expression ')' '{' port_location_list '}'
                {
                        TECSGEN::Cell_location.new( val[1], val[3], val[5], val[7], val[9], val[12] )
                }

port_location_list
        : port_location_list port_location
                {
                        result = val[0] << val[1]
                }
        |
                { result = [] }

port_location
        : IDENTIFIER '(' IDENTIFIER ',' constant_expression ')'
                { result = [ val[0], val[2], val[3] ] }

join_location    # mikan port array
        : __JOIN__ '(' namespace_identifier '.' IDENTIFIER '=>' namespace_identifier '.' IDENTIFIER ')'  '{' bar_list '}'
                {
            TECSGEN::Join_location.new( val[2], val[4], val[6], val[8], val[11] )
                }

bar_list
        : bar_list IDENTIFIER '(' constant_expression ')'
          {
            result = val[0] << [ val[1], val[3] ]
          }
        | { result = [] }


end

---- inner

  RESERVED = {
    # keyword
    'namespace' => :NAMESPACE,
    'signature' => :SIGNATURE,
    'celltype' => :CELLTYPE,
    'cell' => :CELL,
    'attr' => :ATTRIBUTE,
    'var' => :VAR,
    'call' => :CALL,
    'entry' => :ENTRY,
    'composite' => :COMPOSITE,
    'require' => :REQUIRE,
    'factory' => :FACTORY,
    'FACTORY' => :CTFACTORY,
    'typedef' => :TYPEDEF,
    'struct' => :STRUCT,
    'region' => :REGION,
    'import' => :IMPORT,
    'import_C' => :IMPORT_C,
    'generate' => :GENERATE,

    # types
    'void'    => :VOID,

    'volatile'=> :VOLATILE,
    'const'   => :CONST,

    'signed'  => :SIGNED,
    'unsigned'=> :UNSIGNED,

    'int8_t'    => :INT8_T,
    'int16_t'   => :INT16_T,
    'int32_t'   => :INT32_T,
    'int64_t'   => :INT64_T,
    'int128_t'  => :INT128_T,
    'uint8_t'   => :UINT8_T,
    'uint16_t'  => :UINT16_T,
    'uint32_t'  => :UINT32_T,
    'uint64_t'  => :UINT64_T,
    'uint128_t' => :UINT128_T,

    'float32_t'   => :FLOAT32_T,
    'double64_t'  => :DOUBLE64_T,
    'bool_t'      => :BOOL_T,
    'char_t'  => :CHAR_T,
    'schar_t'  => :SCHAR_T,
    'uchar_t'  => :UCHAR_T,

    # unrecommened types
    'int'     => :INT,
#   'intptr'  => :INTPTR,
    'short'   => :SHORT,
    'long'    => :LONG,

    # obsolete types
    'char'    => :CHAR,
#    'int8'    => :INT8,
#    'int16'   => :INT16,
#    'int32'   => :INT32,
#    'int64'   => :INT64,
#    'int128'  => :INT128,
#    'float'   => :FLOAT,
#    'double'  => :DOUBLE,
#    'bool'    => :BOOL,

    'enum'    => :ENUM,
    'enum8'   => :ENUM8,
    'enum16'  => :ENUM16,
    'enum32'  => :ENUM32,
    'enum64'  => :ENUM64,

    'true'    => :TRUE,
    'false'   => :FALSE,

    'C_EXP'   => :C_EXP,

    'Descriptor'   => :DESCRIPTOR,

    # location information for TECSCDE
    '__location_information__' => :__LOCATION_INFORMATION__,
    '__cell__' => :__CELL__,
    '__join__' => :__JOIN__,
  }

  # 指定子 '[]' 内
でのみ使用できるキーワード
  RESERVED2 = {
    # specifier
    'id' => :ID,

    # signature
    'callback' => :CALLBACK,
    'context' => :CONTEXT,
    'deviate' => :DEVIATE,

    # celltype
    'singleton' => :SINGLETON,
    'idx_is_id' => :IDX_IS_ID,
    'active' => :ACTIVE,

    # port (entry)
    'inline' => :INLINE,
    'ref_desc' => :REF_DESC,   # call も可

    # port (call)
    'optional' => :OPTIONAL,
    'dynamic' => :DYNAMIC,

    # port (call), attribute
    'omit' => :OMIT,

    # attribute
    'choice' => :CHOICE,

    # cell
    'allocator' => :ALLOCATOR,
    'prototype' => :PROTOTYPE,
    'restrict'  => :RESTRICT,

    # FuncType
    'oneway' => :ONEWAY,

    # parameter (basic)
    'in' => :IN,
    'out' => :OUT,
    'inout' => :INOUT,
    'send' => :SEND,
    'receive' => :RECEIVE,

    # parameter 
    'size_is' => :SIZE_IS,
    'count_is' => :COUNT_IS,
    'string' => :STRING,
    'nullable' => :NULLABLE,

    'through' => :THROUGH,
    'in_through' => :IN_THROUGH,
    'out_through' => :OUT_THROUGH,
    'to_through' => :TO_THROUGH,

    'node' => :NODE,
    'linkunit' => :LINKUNIT ,
    'domain' => :DOMAIN,
    'class' => :CLASS,
  }

  # 再帰的なパーサのためのスタック
  @@generator_nest = -1
  @@generator_stack = []
  @@current_locale = []

  # import_C 中である
  @@import_C = false

  # すべての構文解析が完了した
  @@b_end_all_parse = false

  def self.parse( file_name, plugin = nil, b_reuse = false )
    # パーサインスタンスを生成(別パーサで読み込む)
    parser = Generator.new

    # plugin から import ã•ã‚Œã¦ã„ã‚‹å ´åˆã® plugin 設定
    parser.set_plugin plugin

    # reuse フラグを設定
    parser.set_reuse b_reuse

    # cdl をパース
    parser.parse( [file_name] )

    # 終期化　パーサスタックを戻す
    parser.finalize
  end

  def finalize

    # mikan Namespace.pop
    Namespace.pop
    Signature.pop
    Celltype.pop
    Cell.pop
    CompositeCelltype.pop
  end

  def set_plugin( plugin )
    @plugin = plugin
  end

  def self.get_plugin
    if @@generator_stack[@@generator_nest] then
      # tecsgen 引数の cdl が import ã•ã‚Œã‚‹å ´åˆã¯ nil
      return @@generator_stack[@@generator_nest].get_plugin
    else
      return nil
    end
  end

  def get_plugin
    @plugin
  end

  def set_reuse( b_reuse )
    @b_reuse = b_reuse
  end

  def self.is_reuse?
    if @@generator_stack[@@generator_nest] then
      # tecsgen 引数の cdl が import ã•ã‚Œã‚‹å ´åˆã¯ nil
      return @@generator_stack[@@generator_nest].is_reuse?
    else
      return false
    end
  end

  def is_reuse?
    @b_reuse
  end

  def parse(files)

    # mikan Namespace.push
    Namespace.push
    Signature.push
    Celltype.push
    Cell.push
    CompositeCelltype.push

    @@generator_nest += 1
    @@generator_stack[@@generator_nest] = self
    @in_specifier = false

    begin

      @q = []
      b_in_comment = false
      b_in_string = false

      # euc のコメントを utf8 として扱うと、コメントの終わりを誤る問題の対策
      TECS_LANG::set_kcode_binary

      files.each {|file|
        lineno = 1
        begin
          string = ""
#2.0          IO.foreach(file) {|line|
          TECSIO.foreach(file) {|line|
            col = 1
#            line.rstrip!         改行含む文字列を扱うようになったので、ここで空白を取り除けなくなった

            until line.empty?

              if b_in_comment
                case line
                  # コメント終了
                when /\A\*\//
                  b_in_comment = false
                when /\A./
                  ;
                when /\s+/     # line.rstrip! を止めたため \n などの空白文字とまっちするルールが必
要になった
                  ;
                end
              elsif b_in_string
                if line =~ /\A(?:[^"\\]|\\.)*"/
                  string = "#{string}#{$&}"
                  @q <<  [:STRING_LITERAL, Token.new(string, file, lineno, col)]
                  b_in_string = false
                elsif line =~ /\A.*\\\n/     # 改行 \n は '.' にマッチしない
                  string += $&
                elsif line =~ /\A.*\n/     # 改行 \n は '.' にマッチしない
                  string += line
                  # この位置では error メソッドは使えない (token 読出し前)
                  puts "error: #{file} line #{lineno}: string literal has newline without escape"
                  @@n_error += 1
                end
              else
                case line
                # 空白、プリプロセスディレクティブ
                when /\A\s+/
                  ;
                # 識別子
                when /\A[a-zA-Z_]\w*/
                  word = $&
                  @q << [RESERVED[word] || :IDENTIFIER, Token.new(word.intern, file, lineno, col)]
                # 16 進数定数
                when /\A0x[0-9A-Fa-f]+/
                  @q << [:HEX_CONSTANT, Token.new($&, file, lineno, col)]
                # 8 進数定数
                when /\A0[0-7]+/
                  @q << [:OCTAL_CONSTANT, Token.new($&, file, lineno, col)]
                # 浮動小数定数
                when /\A[0-9]+\.([0-9]*)?([Ee][+-]?[0-9]+)?/
                  @q << [:FLOATING_CONSTANT, Token.new($&, file, lineno, col)]
                # 整数定数
                when /\A\d+/
                  @q << [:INTEGER_CONSTANT, Token.new($&.to_i, file, lineno, col)]
                # 文字定数
                when /\A'(?:[^'\\]|\\.)'/
                  @q << [:CHARACTER_LITERAL, Token.new($&, file, lineno, col)]
                # 文字列
#                "#include  #include #include \"../systask/logtask.cfg\"       最後の " 忘れ)で無限ループ
#                when /\A"(?:[^"\\]+|\\.)*"/
                when /\A"(?:[^"\\]|\\.)*"/   # これはうまく行くようだ
                  @q << [:STRING_LITERAL, Token.new($&, file, lineno, col)]
                # 文字列 (改行あり)
                when /\A"(?:[^"\\]|\\.)*\\\n$/
                  string = $&
                  b_in_string = true
                # 文字列 (改行あり, escape なし)
                when /\A("(?:[^"\\]|\e\.)*)\n$/
                  string = $1 + "\\\n"
                  b_in_string = true
                  # この位置では error メソッドは使えない (token 読出し前) # mikan cdl_error ではない
                  puts "error: #{file} line #{lineno}: string literal has newline without escape"
                  @@n_error += 1
                # 山括弧で囲まれた文字列
                when /\A<[0-9A-Za-z_\. \/]+>/   # AB: angle bracke
                  @q << [:AB_STRING_LITERAL, Token.new($&, file, lineno, col)]
                # 行コメント
                when /\A\/\/.*$/
                  # 読み飛ばすだけ
                # コメント開始
                when /\A\/\*/
                  b_in_comment = true
                # '>>', '<<' など
                when /\A>>/, /\A<</, /\A==/, /\A!=/, /\A\&\&/, /\A\|\|/
                  @q << [$&, Token.new($&, file, lineno, col)]
                when /\A::/, /\A=>/, /\A<=/, /\A>=/
                  @q << [$&, Token.new($&, file, lineno, col)]
                # '(', ')' など一文字の記号、または未知の記号
                when /\A./
                  @q << [$&, Token.new($&, file, lineno, col)]
                else
                  raise
                end
              end

              line = $'
              col += $&.length
            end

            lineno += 1
          }

        rescue => evar
          Generator.error( "G1014 while open or reading \'$1\'" , file )
          if $debug then
            p puts( evar )
            pp $@
          end
        end
      }

      # 終了の印
      @q << nil

      @yydebug = true
      do_parse

    ensure
      @@generator_nest -= 1
      TECS_LANG::reset_kcode
    end

  end

  def next_token
    token = @q.shift

    if token then
      @@current_locale[@@generator_nest] = token[1].locale

      if token[0] == :IDENTIFIER then
        # TYPE_NAME トークンへ置換え
        if Namespace.is_typename?( token[1].val ) then
          token[0] = :TYPE_NAME
        elsif @in_specifier && RESERVED2[ token[1].val.to_s ] then
          # 指定子キーワード（ '[', ']' 内
でのみ有効)
          token[0] = RESERVED2[ token[1].val.to_s ]
        end
      end

      if $debug then     # 070107 token 無効時ここを通さないようした (through 対応 -d の時に例外発生) 
        locale = @@current_locale[@@generator_nest]
        if token then
          print( "#{locale[0]}: line #{locale[1]} : #{token[0]} '#{token[1].val}'\n" )
        else
          print( "#{locale[0]}: line #{locale[1]} : EOF\n" )
        end
      end
    else
      token = [ false, false ]
    end

    token
  end

  def on_error(t, v, vstack)
    # p t, token_to_str(t), vstack
    if token_to_str(t) == "$end" then
      Generator.error( "G1015 Unexpected EOF"  )
    else
      Generator.error( "G1016 syntax error near \'$1\'" , v.val )
    end
  end

  def self.current_locale
    @@current_locale[ @@generator_nest ]
  end

  @@n_error = 0
  @@n_warning = 0

  # このメソッドは構文解析、意味解析からのみ呼出し可（コード生成でエラー発生は不適切）
  def self.error( msg, *arg )
    locale = nil
    self.error2( locale, msg, *arg )
  end

  def self.error2( locale, msg, *arg )
    @@n_error += 1

    msg = TECSMsg.get_error_message( msg )
    # $1, $2, ... を arg で置換
    count = 1
    arg.each{ |a|
      str = TECSIO.str_code_convert( msg, a.to_s )
      msg.sub!( /\$#{count}/, str )
      count += 1
    }

    # import_C の中でのエラー？
    if @@import_C then
      C_parser.error( msg )
    else

      # Node の記憶する 位置 (locale) ã‚’ä½¿ç”¨ã—ãŸå ´åˆã€å¤‰æ›´ä»¥å‰ã«æ¯”ã¹ã€
      # 問題発生箇所と異なる位置にエラーが出るため、構文解析中のエラー
      # は、解析中の位置を出力する．(new_XXX で owner ãŒå­è¦ç´ ã®ãƒã‚§ãƒƒ
      # クをすると owner の行番号が出てしまう点で、ずれが生じている)

      if @@b_end_all_parse == false || locale == nil then
        locale = @@current_locale[ @@generator_nest ]
      end
      if locale then
        Console.puts "error: #{locale[0]}: line #{locale[1]} #{msg}"
      else
        Console.puts "error: #{msg}"
      end
    end
  end

  # このメソッドは構文解析、意味解析からのみ呼出し可（コード生成でウォーニング発生は不適切）
  def self.warning( msg, *arg )
    locale = nil
    self.warning2( locale, msg, *arg )
  end

  def self.warning2( locale, msg, *arg )
    @@n_warning += 1

    msg = TECSMsg.get_warning_message( msg )
    # $1, $2, ... を arg で置換
    count = 1
    arg.each{ |a|
      str = TECSIO.str_code_convert( msg, a.to_s )
      msg.sub!( /\$#{count}/, str )
      count += 1
    }

    # import_C の中でのウォーニング？
    if @@import_C then
      C_parser.warning( msg )
    else
      if @@b_end_all_parse == false || locale == nil then
        locale = @@current_locale[ @@generator_nest ]
      end
      if locale then
        Console.puts "warning: #{locale[0]}: line #{locale[1]} #{msg}"
      else
        Console.puts "warning: #{msg}"
      end
    end
  end

  def self.get_n_error
    @@n_error
  end

  def self.get_n_warning
    @@n_warning
  end

  def self.get_nest
    @@generator_nest
  end

  #===  '[' specifier 始め
  def set_in_specifier
    # p "set_in_specifier"
    @in_specifier = true
  end

  #=== ']' specifier 終わり
  def unset_in_specifier
    # p "unset_in_specifier"
    @in_specifier = false
  end

  # statement_specifier は構文解釈途中で参ç…
§ã—たいため
  @@statement_specifier_stack = []
  def self.add_statement_specifier( ss )
    if( @@statement_specifier_stack[ @@generator_nest ] == nil )then
      @@statement_specifier_stack[ @@generator_nest ] = [ ss ]
    else
      @@statement_specifier_stack[ @@generator_nest ] << ss
    end
  end


  def self.get_statement_specifier
    spec_list = @@statement_specifier_stack[ @@generator_nest ]
    @@statement_specifier_stack[ @@generator_nest ] = nil
    return spec_list
  end

  #=== ã™ã¹ã¦ã®æ§‹æ–‡è§£æžãŒå®Œäº†ã—ãŸã“ã¨ã‚’å ±å‘Š
  def self.end_all_parse
    @@b_end_all_parse = true
  end

---- footer


# ファイル => INCLUDE("header")のé…
åˆ—
Include = Hash.new {|hash, key| hash[key] = []}


class Token

  attr_accessor :val, :file, :lineno, :col

  def initialize(val, file, lineno, col)
    @val = val
    @file = file
    @lineno = lineno
    @col = col

  end

  def to_s
    @val.to_s
  end

  def to_sym
    @val.to_sym
  end

  def get_name
    @val
  end

  def locale
    [@file, @lineno, @col]
  end

  def eql?(other)
    if other.is_a? Symbol
      @val == other
    elsif other.is_a? Token
      @val == other.val
    elsif other.is_a? String
      @val.to_s == other
    else
      raise ArgumentError
    end
  end

  alias == eql?

  def show_tree( indent )
    indent.times { print "  " }
    print "#{@val}\n"
  end

end

#= TECSIO
#  Ruby2.0(1.9) 対応に伴い導å…
¥ã—たクラス
#  SJIS 以外では、ASCII-8BIT としてå…
¥åŠ›ã™ã‚‹
class TECSIO
  def self.foreach(file) # ブロック引数 { |line| }
    pr = Proc.new   # このメソッドのブロック引数を pr に代å…
¥
    if $b_no_kcode then
          msg = "E".encode $Ruby19_File_Encode
      if( $Ruby19_File_Encode == "Shift_JIS" )

        # Shift JIS は、いったん Windows-31J として読み込ませ、Shift_JIS に変換させる．
        # コメント等に含まれる SJIS に不適切な文字コードは '?' または REPLACEMENT CHARACTER に変換される．
        # EUC や UTF-8 で記述された CDL が混在していても、Ruby 例外が発生することなく処理を進めることができる．
        # 文字コード指定が SJIS であって、文字列リテラルの中に、文字コードがSJIS 以外の非 ASCII ãŒå«ã¾ã‚Œã¦ã„ã‚‹å ´åˆã€
        # Ruby 1.8 の tecsgen では文字コード指定に影響なく処理されたものが、Ruby 1.9 以降では '?' に置き換わる可能性がある．

        mode = "r:Windows-31J"
      else
        mode = "r:#{$Ruby19_File_Encode}"
      end
      # mode = "r"
    else
          msg = "E"
      mode = "r"
    end

    f = File.open( file, mode )
    begin
      f.each{ |line|
        # dbgPrint line
        line = str_code_convert( msg, line )
        pr.call( line )
      }
    ensure
      f.close
    end
  end

  #=== æ–‡å­—ã‚³ãƒ¼ãƒ‰ãŒç›¸é•ã™ã‚‹å ´åˆä¸€è‡´ã•ã›ã‚‹
  # msg と str ã®æ–‡å­—ã‚³ãƒ¼ãƒ‰ãŒç›¸é•ã™ã‚‹å ´åˆã€str を msg の文字コードに変換する
  # 変換不可の文字コードは '?' (utf-8 ã®å ´åˆ U+FFFD (REPLACEMENT CHARACTER )) に変換
  #
  # このメソッドは、エラーメッセージ出力でも使用されていることに注意．
  #
  #msg_enc::Encode | String
  def self.str_code_convert( msg, str )
    if $b_no_kcode == false then
      return str                          # Ruby V1.8 まで
    end
    if msg.encoding != str.encoding then
      option = { :invalid => :replace, :undef => :replace }   # 例外を発生させず、'?' に変換する(utf-8 は 0xfffd)
      # return str.encode( msg.encoding, option )
      str = str.encode( "utf-8", option )
      return str.encode( msg.encoding, option )
    else
      return str
    end
  end
end