source4/build/pidl/idl.gram

   1 {
   2         use util;
   3 }
   4
   5 idl: idl_interface(s)
   6      {{ util::FlattenArray($item[1]) }}
   7   | <error>
   8
   9 idl_interface: module_header interface
  10    { [$item{module_header}, $item{interface}] }
  11    | <error>
  12
  13 module_header: '[' <commit> module_param(s? /,/) ']'
  14           {{
  15               "TYPE" => "MODULEHEADER",
  16               "PROPERTIES" => util::FlattenHash($item[3])
  17           }}
  18               | <error?>
  19
  20 module_param: identifier '(' <commit> text ')'
  21           {{ "$item{identifier}" => "$item{text}" }}
  22           | <error>
  23
  24 interface: 'interface' <commit> identifier '{' definition(s?) '}'
  25           {{
  26                        "TYPE" => "INTERFACE",
  27                        "NAME" => $item{identifier},
  28                        "DATA" => $item[5]
  29           }}
  30           | <error?>
  31
  32 definition : typedef { $item[1] }
  33              | function { $item[1] }
  34              | const { $item[1] }
  35
  36 const : 'const' <commit> identifier identifier '=' anytext ';'
  37         {{
  38                      "TYPE"  => "CONST",
  39                      "DTYPE"  => $item[3],
  40                      "NAME"  => $item[4],
  41                      "VALUE" => $item{anytext}
  42         }}
  43         | <error?>
  44
  45 typedef : 'typedef' <commit> type identifier array_len(?) ';'
  46         {{
  47                      "TYPE" => "TYPEDEF",
  48                      "NAME" => $item{identifier},
  49                      "DATA" => $item{type},
  50                      "ARRAY_LEN" => $item[5][0]
  51         }}
  52         | <error?>
  53
  54 enum: 'enum' <commit> '{' enum_element(s? /,/) '}'
  55         {{
  56                      "TYPE" => "ENUM",
  57                      "ELEMENTS" => $item[4]
  58         }}
  59       | <error?>
  60
  61 enum_element: /[\w\s=]+/
  62
  63 struct: property_list(s?) 'struct' <commit> '{' element_list1(?) '}'
  64         {{
  65                      "TYPE" => "STRUCT",
  66                      "PROPERTIES" => util::FlattenArray($item[1]),
  67                      "ELEMENTS" => util::FlattenArray2($item[5])
  68         }}
  69       | <error?>
  70
  71 union: property_list(s?) 'union' <commit> '{' union_element(s?) '}'
  72          {{
  73                 "TYPE" => "UNION",
  74                 "PROPERTIES" => util::FlattenArray($item[1]),
  75                 "DATA" => $item[5]
  76          }}
  77          | <error?>
  78
  79 union_element:
  80          '[' 'case' '(' identifier ')' ']' base_element ';'
  81          {{
  82                 "TYPE" => "UNION_ELEMENT",
  83                 "CASE" => $item{identifier},
  84                 "DATA" => $item{base_element}
  85          }}
  86          | '[' 'case' '(' identifier ')' ']' ';'
  87          {{
  88                 "TYPE" => "EMPTY",
  89                 "CASE" => $item{identifier},
  90          }}
  91          | '[' 'default' ']' base_element ';'
  92          {{
  93                 "TYPE" => "UNION_ELEMENT",
  94                 "CASE" => "default",
  95                 "DATA" => $item{base_element}
  96          }}
  97          | '[' 'default' ']' ';'
  98          {{
  99                 "TYPE" => "EMPTY",
 100                 "CASE" => "default",
 101          }}
 102
 103 base_element: property_list(s?) type pointer(s?) identifier array_len(?)
 104               {{
 105                            "NAME" => $item{identifier},
 106                            "TYPE" => $item{type},
 107                            "PROPERTIES" => util::FlattenArray($item[1]),
 108                            "POINTERS" => $#{$item[3]}==-1?undef:$#{$item[3]}+1,
 109                            "ARRAY_LEN" => $item[5][0]
 110               }}
 111             | <error>
 112
 113 array_len:
 114          '[' ']'
 115          { "*" }
 116          | '[' '*' ']'
 117          { "*" }
 118          | '[' <commit> anytext ']'
 119          { "$item{anytext}" }
 120          | <error?>
 121
 122 element_list1: base_element(s? /;/) ';'
 123                { $item[1] }
 124
 125 element_list2: 'void'
 126          | base_element(s? /,/)
 127          { $item[1] }
 128
 129 pointer: '*'
 130
 131 property_list: '[' <commit> property(s /,/) ']'
 132               { $item[3] }
 133              | <error?>
 134
 135 property: 'unique'
 136           | 'in'
 137           | 'out'
 138           | 'ref'
 139           | 'public'
 140           | 'noprint'
 141           | 'relative'
 142           | 'nodiscriminant'
 143           | 'subcontext' '(' constant ')' {{ "$item[1]" => "$item{constant}" }}
 144           | 'flag' '(' anytext ')' {{ "$item[1]" => "$item{anytext}" }}
 145           | 'size_is' '(' expression ')' {{ "$item[1]" => "$item{expression}" }}
 146           | 'length_is' '(' expression ')' {{ "$item[1]" => "$item{expression}" }}
 147           | 'switch_is' '(' expression ')' {{ "$item[1]" => "$item{expression}" }}
 148           | 'value' '(' anytext ')' {{ "$item[1]" => "$item{anytext}" }}
 149
 150 identifier: /[\w?]+/
 151
 152 expression: /[\w.?\/+*-_]+/
 153
 154 function : property_list(s?) type identifier '(' <commit> element_list2 ');'
 155          {{
 156                 "TYPE" => "FUNCTION",
 157                 "NAME" => $item{identifier},
 158                 "RETURN_TYPE" => $item{type},
 159                 "PROPERTIES" => util::FlattenArray($item[1]),
 160                 "DATA" => $item{element_list2}
 161          }}
 162          | <error?>
 163
 164 type :
 165        struct    { $item[1] }
 166      | union     { $item[1] }
 167      | enum      { $item[1] }
 168      | identifier { $item[1] }
 169      | <error>
 170
 171 text: /[\w\s\..?-]*/
 172
 173 text2: /[\|\w\s,\*&\>"\/\..?-]*/
 174
 175 anytext: text2 '(' <commit> anytext ')' anytext
 176          {{ "$item[1]($item[4])$item[6]" }}
 177          | text2 '+' anytext
 178          {{ "$item[1]+$item[3]" }}
 179          | text2
 180
 181 constant: /-?[\dx]+/
 182           | '*'
 183