Commit | Line | Data |
---|---|---|
62f43d66 | 1 | ;;; c.by -- LL grammar for C/C++ language specification |
ba318903 | 2 | ;; Copyright (C) 1999-2014 Free Software Foundation, Inc. |
469d2149 CY |
3 | ;; |
4 | ;; Author: Eric M. Ludlam <zappo@gnu.org> | |
5 | ;; David Ponce <david@dponce.com> | |
6 | ;; Klaus Berndl <klaus.berndl@sdm.de> | |
7 | ;; | |
62f43d66 CY |
8 | ;; This file is part of GNU Emacs. |
9 | ||
10 | ;; GNU Emacs is free software: you can redistribute it and/or modify | |
469d2149 | 11 | ;; it under the terms of the GNU General Public License as published by |
62f43d66 CY |
12 | ;; the Free Software Foundation, either version 3 of the License, or |
13 | ;; (at your option) any later version. | |
14 | ||
15 | ;; GNU Emacs is distributed in the hope that it will be useful, | |
469d2149 CY |
16 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | ;; GNU General Public License for more details. | |
62f43d66 | 19 | |
469d2149 | 20 | ;; You should have received a copy of the GNU General Public License |
62f43d66 | 21 | ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. |
469d2149 CY |
22 | |
23 | ;; TODO: From Nate Schley | |
24 | ;; > * Can't parse signature element: "const char* const rmc_ClrTxt" | |
25 | ;; > * Can't parse signature element: "char* const dellog_ClrTxt" | |
26 | ;; > * Can't parse signature element: "const char* dellog_SetTxt" | |
27 | ;; > * Can't parse signature element: "const RmcCmdSSPADetailedStatus& status" | |
28 | ;; > | |
29 | ;; > And FWIW I have seen the following argument cases not handled, even | |
30 | ;; > with no leading/trailing spaces in the split: | |
31 | ;; > | |
32 | ;; > * Can't parse signature element: "const bool currentAlarmStatus" | |
33 | ;; > * Can't parse signature element: "unsigned char mode" | |
34 | ;; > * Can't parse signature element: "TskTimingTask* tsktimingtask" | |
35 | ;; > * Can't parse signature element: "unsigned char htrStatus" | |
36 | ;; > * Can't parse signature element: "char trackPower[]" | |
37 | ;; > * Can't parse signature element: "const RmcCmdMCDetailedStatus& status" | |
38 | ;; > * Can't parse signature element: "RmcBucStatus* rftBucStatus" | |
39 | ||
f79fbbc7 | 40 | %package semantic-c-by |
62a81506 CY |
41 | %provide semantic/bovine/c-by |
42 | ||
43 | %{ | |
f9b697dd GM |
44 | (declare-function semantic-c-reconstitute-token "semantic/bovine/c" |
45 | (tokenpart declmods typedecl)) | |
46 | (declare-function semantic-c-reconstitute-template "semantic/bovine/c" | |
47 | (tag specifier)) | |
48 | (declare-function semantic-expand-c-tag "semantic/bovine/c" (tag)) | |
49 | (declare-function semantic-parse-region "semantic" | |
50 | (start end &optional nonterminal depth returnonerror)) | |
62a81506 | 51 | } |
469d2149 CY |
52 | |
53 | %languagemode c-mode c++-mode | |
54 | %start declaration | |
55 | %scopestart codeblock | |
56 | ||
57 | %token <punctuation> HASH "\\`[#]\\'" | |
58 | %token <punctuation> PERIOD "\\`[.]\\'" | |
59 | %token <punctuation> COLON "\\`[:]\\'" | |
60 | %token <punctuation> SEMICOLON "\\`[;]\\'" | |
61 | %token <punctuation> STAR "\\`[*]\\'" | |
62 | %token <punctuation> AMPERSAND "\\`[&]\\'" | |
63 | %token <punctuation> DIVIDE "\\`[/]\\'" | |
64 | %token <punctuation> PLUS "\\`[+]\\'" | |
65 | %token <punctuation> MINUS "\\`[-]\\'" | |
66 | %token <punctuation> BANG "\\`[!]\\'" | |
67 | %token <punctuation> EQUAL "\\`[=]\\'" | |
68 | %token <punctuation> LESS "\\`[<]\\'" | |
69 | %token <punctuation> GREATER "\\`[>]\\'" | |
70 | %token <punctuation> COMA "\\`[,]\\'" | |
71 | %token <punctuation> TILDE "\\`[~]\\'" | |
72 | %token <punctuation> MOD "\\`[%]\\'" | |
73 | %token <punctuation> HAT "\\`\\^\\'" | |
74 | %token <punctuation> OR "\\`[|]\\'" | |
75 | %token <string> C "\"C\"" | |
76 | %token <string> CPP "\"C\\+\\+\"" | |
77 | %token <number> ZERO "^0$" | |
78 | %token <symbol> RESTRICT "\\<\\(__\\)?restrict\\>" | |
79 | %token <open-paren> LPAREN "(" | |
80 | %token <close-paren> RPAREN ")" | |
81 | %token <open-paren> LBRACE "{" | |
82 | %token <close-paren> RBRACE "}" | |
83 | %token <semantic-list> BRACK_BLCK "\\[.*\\]$" | |
84 | %token <semantic-list> PAREN_BLCK "^(" | |
85 | %token <semantic-list> BRACE_BLCK "^{" | |
86 | %token <semantic-list> VOID_BLCK "^(void)$" | |
87 | %token <semantic-list> PARENS "()" | |
88 | %token <semantic-list> BRACKETS "\\[\\]" | |
89 | ||
90 | %token EXTERN "extern" | |
91 | %put EXTERN summary "Declaration Modifier: extern <type> <name> ..." | |
92 | %token STATIC "static" | |
93 | %put STATIC summary "Declaration Modifier: static <type> <name> ..." | |
94 | %token CONST "const" | |
95 | %put CONST summary "Declaration Modifier: const <type> <name> ..." | |
96 | %token VOLATILE "volatile" | |
97 | %put VOLATILE summary "Declaration Modifier: volatile <type> <name> ..." | |
98 | %token REGISTER "register" | |
99 | %put REGISTER summary "Declaration Modifier: register <type> <name> ..." | |
100 | %token SIGNED "signed" | |
101 | %put SIGNED summary "Numeric Type Modifier: signed <numeric type> <name> ..." | |
102 | %token UNSIGNED "unsigned" | |
103 | %put UNSIGNED summary "Numeric Type Modifier: unsigned <numeric type> <name> ..." | |
104 | ||
105 | %token INLINE "inline" | |
106 | %put INLINE summary "Function Modifier: inline <return type> <name>(...) {...};" | |
107 | %token VIRTUAL "virtual" | |
108 | %put VIRTUAL summary "Method Modifier: virtual <type> <name>(...) ..." | |
109 | %token MUTABLE "mutable" | |
110 | %put MUTABLE summary "Member Declaration Modifier: mutable <type> <name> ..." | |
62a81506 CY |
111 | %token EXPLICIT "explicit" |
112 | %put EXPLICIT summary "Forbids implicit type conversion: explicit <constructor>" | |
469d2149 CY |
113 | |
114 | %token STRUCT "struct" | |
115 | %put STRUCT summary "Structure Type Declaration: struct [name] { ... };" | |
116 | %token UNION "union" | |
117 | %put UNION summary "Union Type Declaration: union [name] { ... };" | |
118 | %token ENUM "enum" | |
119 | %put ENUM summary "Enumeration Type Declaration: enum [name] { ... };" | |
120 | %token TYPEDEF "typedef" | |
121 | %put TYPEDEF summary "Arbitrary Type Declaration: typedef <typedeclaration> <name>;" | |
122 | %token CLASS "class" | |
123 | %put CLASS summary "Class Declaration: class <name>[:parents] { ... };" | |
124 | %token TYPENAME "typename" | |
125 | %put TYPENAME summary "typename is used to handle a qualified name as a typename;" | |
126 | %token NAMESPACE "namespace" | |
127 | %put NAMESPACE summary "Namespace Declaration: namespace <name> { ... };" | |
128 | %token USING "using" | |
129 | %put USING summary "using <namespace>;" | |
130 | ||
131 | %token NEW "new" | |
132 | %put NEW summary "new <classname>();" | |
133 | %token DELETE "delete" | |
134 | %put DELETE summary "delete <object>;" | |
135 | ||
136 | ;; Despite this, this parser can find templates by ignoring the TEMPLATE | |
40ba43b4 | 137 | ;; keyword, and finding the class/method being templatized. |
469d2149 CY |
138 | %token TEMPLATE "template" |
139 | %put TEMPLATE summary "template <class TYPE ...> TYPE_OR_FUNCTION" | |
140 | ||
141 | %token THROW "throw" | |
142 | %put THROW summary "<type> <methoddef> (<method args>) throw (<exception>) ..." | |
143 | %token REENTRANT "reentrant" | |
144 | %put REENTRANT summary "<type> <methoddef> (<method args>) reentrant ..." | |
145 | %token TRY "try" | |
146 | %token CATCH "catch" | |
147 | %put { TRY CATCH } summary "try { <body> } catch { <catch code> }" | |
148 | ||
149 | ;; Leave these alone for now. | |
150 | %token OPERATOR "operator" | |
151 | %token PUBLIC "public" | |
152 | %token PRIVATE "private" | |
153 | %token PROTECTED "protected" | |
154 | %token FRIEND "friend" | |
155 | %put FRIEND summary "friend class <CLASSNAME>" | |
156 | ||
157 | ;; These aren't used for parsing, but is a useful place to describe the keywords. | |
158 | %token IF "if" | |
159 | %token ELSE "else" | |
160 | %put {IF ELSE} summary "if (<condition>) { code } [ else { code } ]" | |
161 | ||
162 | %token DO "do" | |
163 | %token WHILE "while" | |
164 | %put DO summary " do { code } while (<condition>);" | |
165 | %put WHILE summary "do { code } while (<condition>); or while (<condition>) { code };" | |
166 | ||
167 | %token FOR "for" | |
168 | %put FOR summary "for(<init>; <condition>; <increment>) { code }" | |
169 | ||
170 | %token SWITCH "switch" | |
171 | %token CASE "case" | |
172 | %token DEFAULT "default" | |
173 | %put {SWITCH CASE DEFAULT} summary | |
174 | "switch (<variable>) { case <constvalue>: code; ... default: code; }" | |
175 | ||
176 | %token RETURN "return" | |
177 | %put RETURN summary "return <value>;" | |
178 | ||
179 | %token BREAK "break" | |
180 | %put BREAK summary "Non-local exit within a loop or switch (for, do/while, switch): break;" | |
181 | %token CONTINUE "continue" | |
182 | %put CONTINUE summary "Non-local continue within a loop (for, do/while): continue;" | |
183 | ||
184 | %token SIZEOF "sizeof" | |
185 | %put SIZEOF summary "Compile time macro: sizeof(<type or variable>) // size in bytes" | |
186 | ||
187 | ;; Types | |
188 | %token VOID "void" | |
189 | %put VOID summary "Built in typeless type: void" | |
190 | %token CHAR "char" | |
191 | %put CHAR summary "Integral Character Type: (0 to 256)" | |
192 | %token WCHAR "wchar_t" | |
193 | %put WCHAR summary "Wide Character Type" | |
194 | %token SHORT "short" | |
195 | %put SHORT summary "Integral Primitive Type: (-32768 to 32767)" | |
196 | %token INT "int" | |
197 | %put INT summary "Integral Primitive Type: (-2147483648 to 2147483647)" | |
198 | %token LONG "long" | |
199 | %put LONG summary "Integral primitive type (-9223372036854775808 to 9223372036854775807)" | |
200 | %token FLOAT "float" | |
201 | %put FLOAT summary "Primitive floating-point type (single-precision 32-bit IEEE 754)" | |
202 | %token DOUBLE "double" | |
203 | %put DOUBLE summary "Primitive floating-point type (double-precision 64-bit IEEE 754)" | |
204 | %token BOOL "bool" | |
205 | %put BOOL summary "Primitive boolean type" | |
206 | ||
207 | %token UNDERP "_P" | |
208 | %token UNDERUNDERP "__P" | |
209 | %put UNDERP summary "Common macro to eliminate prototype compatibility on some compilers" | |
210 | %put UNDERUNDERP summary "Common macro to eliminate prototype compatibility on some compilers" | |
211 | ||
212 | %% | |
213 | ||
214 | declaration | |
215 | : macro | |
216 | | type | |
217 | ;; TODO: Klaus Berndl: Is the define here necessary or even wrong? | |
218 | ;; Is this part not already covered by macro?? | |
219 | | define | |
220 | | var-or-fun | |
221 | | extern-c | |
222 | | template | |
223 | | using | |
224 | ; | |
225 | ||
226 | codeblock | |
227 | : define | |
228 | | codeblock-var-or-fun | |
229 | | type ;; type is less likely to be used here. | |
230 | | using | |
231 | ; | |
232 | ||
233 | extern-c-contents | |
234 | : open-paren | |
235 | ( nil ) | |
236 | | declaration | |
237 | | close-paren | |
238 | ( nil ) | |
239 | ; | |
240 | ||
241 | extern-c | |
242 | : EXTERN C semantic-list | |
243 | ;; Extern C commands which contain a list need to have the | |
244 | ;; entries of the list extracted, and spliced into the main | |
245 | ;; list of entries. This must be done via the function | |
246 | ;; that expands singular nonterminals, such as int x,y; | |
247 | (TAG "C" 'extern :members (EXPANDFULL $3 extern-c-contents) ) | |
248 | | EXTERN CPP semantic-list | |
249 | (TAG "C" 'extern :members (EXPANDFULL $3 extern-c-contents) ) | |
250 | | EXTERN C | |
251 | ;; A plain extern "C" call should add something to the token, | |
252 | ;; but just strip it from the buffer here for now. | |
253 | ( nil ) | |
254 | | EXTERN CPP | |
255 | ( nil ) | |
256 | ; | |
257 | ||
258 | macro | |
259 | : spp-macro-def | |
260 | (VARIABLE-TAG $1 nil nil :constant-flag t ) | |
261 | | spp-system-include | |
262 | (INCLUDE-TAG $1 t) | |
263 | | spp-include | |
264 | (INCLUDE-TAG $1 nil) | |
265 | ; | |
266 | ||
267 | ;; This is used in struct parts. | |
268 | define | |
269 | : spp-macro-def | |
270 | (VARIABLE-TAG $1 nil nil :constant-flag t) | |
271 | | spp-macro-undef | |
272 | ( nil ) | |
273 | ; | |
274 | ||
275 | ;; In C++, structures can have the same things as classes. | |
22bcf204 | 276 | ;; So delete this some day in the figure. |
469d2149 CY |
277 | ;; |
278 | ;;structparts : semantic-list | |
279 | ;; (EXPANDFULL $1 structsubparts) | |
280 | ;; ; | |
281 | ;; | |
282 | ;;structsubparts : LBRACE | |
283 | ;; ( nil ) | |
284 | ;; | RBRACE | |
285 | ;; ( nil ) | |
286 | ;; | var-or-fun | |
287 | ;; | define | |
288 | ;; ;; sometimes there are defines in structs. | |
289 | ;; ; | |
290 | ||
291 | unionparts | |
292 | : semantic-list | |
293 | (EXPANDFULL $1 classsubparts) | |
294 | ; | |
295 | ||
296 | opt-symbol | |
297 | : symbol | |
298 | | ;;EMPTY | |
299 | ; | |
300 | ||
301 | ;; @todo - support 'friend' construct. | |
302 | classsubparts | |
303 | : LBRACE | |
304 | ( nil ) | |
305 | | RBRACE | |
306 | ( nil ) | |
307 | | class-protection opt-symbol COLON | |
308 | ;; For QT, they may put a `slot' keyword between the protection | |
309 | ;; and the COLON. @todo - Have the QT stuff use macros. | |
310 | (TAG (car $1) 'label) | |
311 | | var-or-fun | |
312 | | FRIEND func-decl | |
313 | (TAG (car $2) 'friend) | |
314 | | FRIEND CLASS symbol | |
315 | (TAG $3 'friend) | |
316 | | type | |
317 | | define | |
318 | | template | |
319 | | ;;EMPTY | |
320 | ; | |
321 | ||
322 | opt-class-parents | |
323 | : COLON class-parents opt-template-specifier | |
324 | ( $2 ) | |
325 | | ;;EMPTY | |
326 | ( ) | |
327 | ; | |
328 | ||
329 | one-class-parent | |
330 | : opt-class-protection opt-class-declmods namespace-symbol | |
331 | (TYPE-TAG (car $3) "class" nil nil :protection (car $1)) | |
332 | | opt-class-declmods opt-class-protection namespace-symbol | |
333 | (TYPE-TAG (car $3) "class" nil nil :protection (car $2)) | |
334 | ; | |
335 | ||
336 | class-parents | |
337 | : one-class-parent COMA class-parents | |
338 | ( ,(cons ,$1 $3 ) ) | |
339 | | one-class-parent | |
340 | ( $1 ) | |
341 | ; | |
342 | ||
343 | opt-class-declmods | |
344 | : class-declmods opt-class-declmods | |
345 | ( nil ) | |
346 | | ;;EMPTY | |
347 | ; | |
348 | ||
349 | class-declmods | |
350 | : VIRTUAL | |
351 | ; | |
352 | ||
353 | class-protection | |
354 | : PUBLIC | |
355 | | PRIVATE | |
356 | | PROTECTED | |
357 | ; | |
358 | ||
359 | opt-class-protection | |
360 | : class-protection | |
361 | ( ,$1 ) | |
362 | | ;;EMPTY - Same as private | |
363 | ( "unspecified" ) | |
364 | ; | |
365 | ||
366 | namespaceparts | |
367 | : semantic-list | |
368 | (EXPANDFULL $1 namespacesubparts) | |
369 | ; | |
370 | ||
371 | namespacesubparts | |
372 | : LBRACE | |
373 | ( nil ) | |
374 | | RBRACE | |
375 | ( nil ) | |
376 | | type | |
377 | | var-or-fun | |
378 | | define | |
379 | | class-protection COLON | |
380 | (TAG (car $1) 'label) | |
381 | ;; In C++, this label in a classsubpart represents | |
382 | ;; PUBLIC or PRIVATE bits. Ignore them for now. | |
383 | | template | |
384 | | using | |
62a81506 CY |
385 | ;; Includes inside namespaces |
386 | | spp-include | |
387 | (TAG $1 'include :inside-ns t) | |
469d2149 CY |
388 | | ;;EMPTY |
389 | ; | |
390 | ||
391 | enumparts | |
392 | : semantic-list | |
393 | (EXPANDFULL $1 enumsubparts) | |
394 | ; | |
395 | ||
396 | enumsubparts | |
397 | : symbol opt-assign | |
398 | (VARIABLE-TAG $1 "int" (car $2) :constant-flag t ) | |
399 | | LBRACE | |
400 | ( nil ) | |
401 | | RBRACE | |
402 | ( nil ) | |
403 | | COMA | |
404 | ( nil ) | |
405 | ; | |
406 | ||
407 | opt-name | |
408 | : symbol | |
409 | | ;;EMPTY | |
410 | ( "" ) | |
411 | ; | |
412 | ||
413 | typesimple | |
414 | : struct-or-class opt-class opt-name opt-template-specifier | |
415 | opt-class-parents semantic-list | |
416 | (TYPE-TAG (car $3) (car $1) | |
417 | (let ((semantic-c-classname (cons (car ,$3) (car ,$1)))) | |
418 | (EXPANDFULL $6 classsubparts)) | |
419 | $5 | |
420 | :template-specifier $4 | |
421 | :parent (car ,$2)) | |
422 | | struct-or-class opt-class opt-name opt-template-specifier | |
423 | opt-class-parents | |
424 | (TYPE-TAG (car $3) (car $1) nil $5 | |
425 | :template-specifier $4 | |
426 | :prototype t | |
427 | :parent (car ,$2)) | |
428 | | UNION opt-class opt-name unionparts | |
429 | (TYPE-TAG (car $3) $1 $4 nil | |
430 | :parent (car ,$2)) | |
431 | | ENUM opt-class opt-name enumparts | |
432 | (TYPE-TAG (car $3) $1 $4 nil | |
433 | :parent (car ,$2)) | |
434 | ;; Klaus Berndl: a typedef can be a typeformbase with all this | |
435 | ;; declmods stuff. | |
436 | | TYPEDEF declmods typeformbase cv-declmods typedef-symbol-list | |
437 | ;;;; We put the type this typedef renames into PARENT | |
438 | ;;;; but will move it in the expand function. | |
439 | (TYPE-TAG $5 $1 nil (list $3) ) | |
440 | ; | |
441 | ||
442 | typedef-symbol-list | |
443 | : typedefname COMA typedef-symbol-list | |
444 | ( ,(cons $1 $3) ) | |
445 | | typedefname | |
446 | ( $1 ) | |
447 | ; | |
448 | ||
449 | ;; TODO: Klaus Berndl: symbol -> namespace-symbol?! Answer: Probably | |
450 | ;; symbol is correct here! | |
451 | typedefname | |
452 | : opt-stars symbol opt-bits opt-array | |
453 | ( $1 $2 ) | |
454 | ; | |
455 | ||
456 | struct-or-class | |
457 | : STRUCT | |
458 | | CLASS | |
459 | ; | |
460 | ||
461 | type | |
462 | : typesimple SEMICOLON | |
463 | ( ,$1 ) | |
464 | ;; named namespaces like "namespace XXX {" | |
465 | | NAMESPACE symbol namespaceparts | |
466 | (TYPE-TAG $2 $1 $3 nil ) | |
467 | ;; unnamed namespaces like "namespace {" | |
468 | | NAMESPACE namespaceparts | |
469 | (TYPE-TAG "unnamed" $1 $2 nil ) | |
470 | ;; David Engster: namespace alias like "namespace foo = bar;" | |
471 | | NAMESPACE symbol EQUAL typeformbase SEMICOLON | |
472 | (TYPE-TAG $2 $1 (list (TYPE-TAG (car $4) $1 nil nil)) nil :kind 'alias ) | |
473 | ; | |
474 | ||
475 | ;; Klaus Berndl: We must parse "using namespace XXX" too | |
476 | ||
477 | ;; Using is vaguely like an include statement in the named portions | |
478 | ;; of the code. We should probably specify a new token type for this. | |
479 | ||
480 | using | |
481 | : USING usingname SEMICOLON | |
482 | (TAG (car $2) 'using :type ,$2 ) | |
483 | ; | |
484 | ||
485 | ;; Jan Moringen: Differentiate between 'using' and 'using namespace' | |
486 | ;; Adapted to creating type tags by EML. | |
487 | usingname | |
488 | : typeformbase | |
489 | (TYPE-TAG (car $1) "class" nil nil :prototype t) | |
490 | | NAMESPACE typeformbase | |
491 | (TYPE-TAG (car $2) "namespace" nil nil :prototype t) | |
492 | ; | |
493 | ||
494 | template | |
495 | : TEMPLATE template-specifier opt-friend template-definition | |
496 | ( ,(semantic-c-reconstitute-template $4 ,$2) ) | |
497 | ; | |
498 | ||
499 | opt-friend | |
500 | : FRIEND | |
501 | | ;;EMPTY | |
502 | ; | |
503 | ||
504 | opt-template-specifier | |
505 | : template-specifier | |
506 | ( ,$1 ) | |
507 | | ;;EMPTY | |
508 | ( ) | |
509 | ; | |
510 | ||
511 | template-specifier | |
512 | : LESS template-specifier-types GREATER | |
513 | ( ,$2 ) | |
514 | ; | |
515 | ||
516 | template-specifier-types | |
517 | : template-var template-specifier-type-list | |
518 | ( ,(cons ,$1 ,$2 ) ) | |
519 | | ;;EMPTY | |
520 | ; | |
521 | ||
522 | template-specifier-type-list | |
523 | : COMA template-specifier-types | |
524 | ( ,$2 ) | |
525 | | ;;EMPTY | |
526 | ( ) | |
527 | ; | |
528 | ||
529 | ;; template-var | |
530 | ;; : template-type opt-stars opt-template-equal | |
531 | ;; ( ,(cons (concat (car $1) (make-string (car ,$2) ?*)) | |
532 | ;; (cdr $1))) | |
533 | ;; ;; Klaus Berndl: for template-types the template-var can also be | |
534 | ;; ;; literals or constants. Example: map<ClassX, ClassY, 10> | |
535 | ;; ;; map_size10_var; This parses also template<class T, 0> which is | |
536 | ;; ;; nonsense but who cares.... | |
537 | ;; | string | |
538 | ;; ( $1 ) | |
539 | ;; | number | |
540 | ;; ( $1 ) | |
541 | ;; ; | |
542 | ||
543 | template-var | |
544 | : | |
545 | ;; Klaus Berndl: The following handles all template-vars of | |
546 | ;; template-definitions | |
547 | template-type opt-template-equal | |
548 | ( ,(cons (car $1) (cdr $1)) ) | |
549 | ;; Klaus Berndl: for template-types the template-var can also be | |
550 | ;; literals or constants. | |
551 | ;; Example: map<ClassX, ClassY, 10> map_size10_var; This parses also | |
552 | ;; template<class T, 0> which is nonsense but who cares.... | |
553 | | string | |
554 | ( $1 ) | |
555 | | number | |
556 | ( $1 ) | |
557 | ;; Klaus Berndl: In template-types arguments can be any symbols with | |
558 | ;; optional address-operator (&) and optional dereferencing operator | |
559 | ;; (*). Example map<ClassX, ClassY, *size_var_ptr> sized_map_var. | |
560 | | opt-stars opt-ref namespace-symbol | |
561 | ( ,$3 ) | |
562 | ;; Some code can compile down into a number, but starts out as an | |
563 | ;; expression, such as "sizeof(a)", or (sizeof(a)/sizeof(b)) | |
564 | | semantic-list | |
565 | ( $1 ) | |
566 | | SIZEOF semantic-list | |
567 | ( $2 ) | |
568 | ; | |
569 | ||
570 | opt-template-equal | |
571 | : EQUAL symbol LESS template-specifier-types GREATER | |
572 | ( $2 ) | |
573 | | EQUAL symbol | |
574 | ( $2 ) | |
575 | | ;;EMPTY | |
576 | ( ) | |
577 | ; | |
578 | ||
579 | template-type | |
580 | : CLASS symbol | |
581 | (TYPE-TAG $2 "class" nil nil ) | |
582 | | STRUCT symbol | |
583 | (TYPE-TAG $2 "struct" nil nil ) | |
58179cce | 584 | ;; TODO: Klaus Berndl: For the moment it is ok, that we parse the C++ |
469d2149 CY |
585 | ;; keyword typename as a class.... |
586 | | TYPENAME symbol | |
587 | (TYPE-TAG $2 "class" nil nil) | |
588 | ;; Klaus Berndl: template-types can be all flavors of variable-args | |
589 | ;; but here the argument is ignored, only the type stuff is needed. | |
590 | | declmods typeformbase cv-declmods opt-stars | |
591 | opt-ref variablearg-opt-name | |
592 | (TYPE-TAG (car $2) nil nil nil | |
593 | :constant-flag (if (member "const" (append $1 $3)) t nil) | |
594 | :typemodifiers (delete "const" (append $1 $3)) | |
595 | :reference (car ,$5) | |
596 | :pointer (car $4) | |
597 | ) | |
598 | ; | |
599 | ||
600 | template-definition | |
601 | : type | |
602 | ( ,$1 ) | |
603 | | var-or-fun | |
604 | ( ,$1 ) | |
605 | ; | |
606 | ||
607 | opt-stars | |
608 | : STAR opt-starmod opt-stars | |
609 | ( (1+ (car $3)) ) | |
610 | | ;;EMPTY | |
611 | ( 0 ) | |
612 | ; | |
613 | ||
614 | opt-starmod | |
615 | : STARMOD opt-starmod | |
616 | ( ,(cons (,car ,$1) $2) ) | |
617 | | ;;EMPTY | |
618 | () | |
619 | ; | |
620 | ||
621 | STARMOD | |
622 | : CONST | |
623 | ; | |
624 | ||
625 | declmods | |
626 | : DECLMOD declmods | |
627 | ( ,(cons ,(car ,$1) $2 ) ) | |
628 | | DECLMOD | |
629 | ( ,$1 ) | |
630 | | ;;EMPTY | |
631 | () | |
632 | ; | |
633 | ||
634 | DECLMOD | |
635 | : EXTERN | |
636 | | STATIC | |
637 | | CVDECLMOD | |
638 | ;; Klaus Berndl: IMHO signed and unsigned are not decl-modes but | |
639 | ;; these are only valid for some buildin-types like short, int | |
640 | ;; etc... whereas "real" declmods are valid for all types, buildin | |
641 | ;; and user-defined! SIGNED UNSIGNED | |
642 | | INLINE | |
643 | | REGISTER | |
644 | | FRIEND | |
645 | ;; Klaus Berndl: There can be a few cases where TYPENAME is not | |
646 | ;; allowed in C++-syntax but better than not recognizing the allowed | |
647 | ;; situations. | |
648 | | TYPENAME | |
649 | | METADECLMOD | |
650 | ;; This is a hack in case we are in a class. | |
651 | | VIRTUAL | |
652 | ; | |
653 | ||
654 | metadeclmod | |
655 | : METADECLMOD | |
656 | () | |
657 | | ;;EMPTY | |
658 | () | |
659 | ; | |
660 | ||
661 | CVDECLMOD | |
662 | : CONST | |
663 | | VOLATILE | |
664 | ; | |
665 | ||
666 | cv-declmods | |
667 | : CVDECLMOD cv-declmods | |
668 | ( ,(cons ,(car ,$1) $2 ) ) | |
669 | | CVDECLMOD | |
670 | ( ,$1 ) | |
671 | | ;;EMPTY | |
672 | () | |
673 | ; | |
674 | ||
675 | METADECLMOD | |
676 | : VIRTUAL | |
677 | | MUTABLE | |
678 | ; | |
679 | ||
680 | ;; C++: A type can be modified into a reference by "&" | |
681 | opt-ref | |
682 | : AMPERSAND | |
683 | ( 1 ) | |
684 | | ;;EMPTY | |
685 | ( 0 ) | |
686 | ; | |
687 | ||
688 | typeformbase | |
689 | : typesimple | |
690 | ( ,$1 ) | |
691 | | STRUCT symbol | |
692 | (TYPE-TAG $2 $1 nil nil ) | |
693 | | UNION symbol | |
694 | (TYPE-TAG $2 $1 nil nil ) | |
695 | | ENUM symbol | |
696 | (TYPE-TAG $2 $1 nil nil ) | |
697 | | builtintype | |
698 | ( ,$1 ) | |
699 | | symbol template-specifier | |
700 | (TYPE-TAG $1 "class" nil nil :template-specifier $2) | |
701 | ;;| namespace-symbol opt-stars opt-template-specifier | |
702 | ;;| namespace-symbol opt-template-specifier | |
703 | | namespace-symbol-for-typeformbase opt-template-specifier | |
704 | (TYPE-TAG (car $1) "class" nil nil | |
705 | :template-specifier $2) | |
706 | | symbol | |
707 | ( $1 ) | |
708 | ; | |
709 | ||
710 | signedmod | |
711 | : UNSIGNED | |
712 | | SIGNED | |
713 | ; | |
714 | ||
715 | ;; Klaus Berndl: builtintype-types was builtintype | |
716 | builtintype-types | |
717 | : VOID | |
718 | | CHAR | |
719 | ;; Klaus Berndl: Added WCHAR | |
720 | | WCHAR | |
721 | | SHORT INT | |
722 | ( (concat $1 " " $2) ) | |
723 | | SHORT | |
724 | | INT | |
725 | | LONG INT | |
726 | ( (concat $1 " " $2) ) | |
727 | | FLOAT | |
728 | | DOUBLE | |
729 | | BOOL | |
730 | | LONG DOUBLE | |
731 | ( (concat $1 " " $2) ) | |
732 | ;; TODO: Klaus Berndl: Is there a long long, i think so?! | |
733 | | LONG LONG | |
734 | ( (concat $1 " " $2) ) | |
735 | | LONG | |
736 | ; | |
737 | ||
738 | builtintype | |
739 | : signedmod builtintype-types | |
740 | ( (concat (car $1) " " (car $2)) ) | |
741 | | builtintype-types | |
742 | ( ,$1 ) | |
743 | ;; Klaus Berndl: unsigned is synonym for unsigned int and signed for | |
744 | ;; signed int. To make this confusing stuff clear we add here the | |
745 | ;; int. | |
746 | | signedmod | |
747 | ( (concat (car $1) " int") ) | |
748 | ; | |
749 | ||
750 | ;; Klaus Berndl: This parses also nonsense like "const volatile int | |
751 | ;; const volatile const const volatile a ..." but IMHO nobody writes | |
09e80d9f | 752 | ;; such code. Normally we should define a rule like typeformbase-mode |
469d2149 CY |
753 | ;; which exactly defines the different allowed cases and combinations |
754 | ;; of declmods (minus the CVDECLMOD) typeformbase and cv-declmods so | |
755 | ;; we could recognize more invalid code but IMHO this is not worth the | |
756 | ;; effort... | |
757 | codeblock-var-or-fun | |
758 | : declmods typeformbase declmods | |
759 | opt-ref var-or-func-decl | |
760 | ( ,(semantic-c-reconstitute-token ,$5 $1 $2 ) ) | |
761 | ; | |
762 | ||
763 | var-or-fun | |
764 | : codeblock-var-or-fun | |
765 | ( ,$1 ) | |
766 | ;; it is possible for a function to not have a type, and | |
767 | ;; it is then assumed to be an int. How annoying. | |
768 | ;; In C++, this could be a constructor or a destructor. | |
769 | ;; Even more annoying. Only ever do this for regular | |
770 | ;; top-level items. Ignore this problem in code blocks | |
771 | ;; so that we don't have to deal with regular code | |
772 | ;; being erroneously converted into types. | |
773 | | declmods var-or-func-decl | |
774 | ( ,(semantic-c-reconstitute-token ,$2 $1 nil ) ) | |
775 | ; | |
776 | ||
777 | var-or-func-decl | |
778 | : func-decl | |
779 | ( ,$1 ) | |
780 | | var-decl | |
781 | ( ,$1 ) | |
782 | ; | |
783 | ||
784 | func-decl | |
785 | : opt-stars opt-class opt-destructor functionname | |
786 | opt-template-specifier | |
787 | opt-under-p | |
788 | arg-list | |
789 | opt-post-fcn-modifiers | |
790 | opt-throw | |
791 | opt-initializers | |
792 | fun-or-proto-end | |
793 | ( ,$4 'function | |
794 | ;; Extra stuff goes in here. | |
795 | ;; Continue with the stuff we found in | |
796 | ;; this definition | |
797 | $2 $3 $7 $9 $8 ,$1 ,$11 $5 ,$10) | |
798 | | opt-stars opt-class opt-destructor functionname | |
799 | opt-template-specifier | |
800 | opt-under-p | |
801 | ;; arg-list - - ini this case, a try implies a fcn. | |
802 | opt-post-fcn-modifiers | |
803 | opt-throw | |
804 | opt-initializers | |
805 | fun-try-end | |
806 | ( ,$4 'function | |
807 | ;; Extra stuff goes in here. | |
808 | ;; Continue with the stuff we found in | |
809 | ;; this definition | |
810 | $2 $3 nil $8 $7 ,$1 ,$10 $5 ,$9) | |
811 | ; | |
812 | ||
813 | var-decl | |
814 | : varnamelist SEMICOLON | |
815 | ( $1 'variable ) | |
816 | ; | |
817 | ||
818 | opt-under-p | |
819 | : UNDERP | |
820 | ( nil ) | |
821 | | UNDERUNDERP | |
822 | ( nil ) | |
823 | | ;;EMPTY | |
824 | ; | |
825 | ||
826 | ;; Klaus Berndl: symbol -> namespace-symbol | |
827 | opt-initializers | |
828 | : COLON namespace-symbol semantic-list opt-initializers | |
829 | | COMA namespace-symbol semantic-list opt-initializers | |
830 | | ;;EMPTY | |
831 | ; | |
832 | ||
833 | opt-post-fcn-modifiers | |
834 | : post-fcn-modifiers opt-post-fcn-modifiers | |
835 | ( ,(cons ,$1 $2) ) | |
836 | | ;;EMPTY | |
837 | ( nil ) | |
838 | ; | |
839 | ||
840 | post-fcn-modifiers | |
841 | : REENTRANT | |
842 | | CONST | |
843 | ; | |
844 | ||
845 | opt-throw | |
846 | : THROW semantic-list | |
847 | ( EXPAND $2 throw-exception-list ) | |
848 | | ;;EMPTY | |
849 | ; | |
850 | ||
851 | ;; Is this true? I don't actually know. | |
852 | throw-exception-list | |
853 | : namespace-symbol COMA throw-exception-list | |
854 | ( ,(cons (car $1) $3) ) | |
855 | | namespace-symbol RPAREN | |
856 | ( ,$1 ) | |
857 | | symbol RPAREN | |
858 | ( $1 ) | |
859 | | LPAREN throw-exception-list | |
860 | ( ,$2 ) | |
861 | | RPAREN | |
862 | ( ) | |
863 | ; | |
864 | ||
865 | opt-bits | |
866 | : COLON number | |
867 | ( $2 ) | |
868 | | ;;EMPTY | |
869 | ( nil ) | |
870 | ; | |
871 | ||
872 | opt-array | |
873 | : BRACK_BLCK opt-array | |
874 | ;; Eventually we want to replace the 1 below with a size | |
875 | ;; (if available) | |
876 | ( (cons 1 (car ,$2) ) ) | |
877 | | ;;EMPTY | |
878 | ( nil ) | |
879 | ; | |
880 | ||
881 | opt-assign | |
882 | : EQUAL expression | |
883 | ( $2 ) | |
884 | | ;;EMPTY | |
885 | ( nil ) | |
886 | ; | |
887 | ||
888 | opt-restrict | |
889 | : RESTRICT | |
890 | | ;;EMPTY | |
891 | ; | |
892 | ||
893 | ;; Klaus Berndl: symbol -> namespace-symbol?! I think so. Can be that | |
894 | ;; then also some invalid C++-syntax is parsed but this is better than | |
895 | ;; not parsing valid syntax. | |
896 | varname | |
897 | : opt-stars opt-restrict namespace-symbol opt-bits opt-array | |
898 | ( ,$3 ,$1 ,$4 ,$5 ) | |
899 | ; | |
900 | ||
901 | ;; I should store more in this def, but leave it simple for now. | |
902 | ;; Klaus Berndl: const and volatile can be written after the type! | |
903 | variablearg | |
b0fe992f DE |
904 | : declmods typeformbase cv-declmods opt-ref variablearg-opt-name opt-assign |
905 | ( VARIABLE-TAG (list (append $5 ,$6)) $2 nil | |
469d2149 CY |
906 | :constant-flag (if (member "const" (append $1 $3)) t nil) |
907 | :typemodifiers (delete "const" (append $1 $3)) | |
908 | :reference (car ,$4) | |
909 | ) | |
910 | ; | |
911 | ||
912 | variablearg-opt-name | |
913 | : varname | |
914 | ( ,$1 ) | |
b0fe992f DE |
915 | | semantic-list arg-list |
916 | ( (car ( EXPAND $1 function-pointer )) $2) | |
469d2149 CY |
917 | ;; Klaus Berndl: This allows variableargs without a arg-name being |
918 | ;; parsed correct even if there several pointers (*) | |
919 | | opt-stars | |
920 | ( "" ,$1 nil nil nil ) | |
921 | ; | |
922 | ||
923 | varname-opt-initializer | |
924 | : semantic-list | |
925 | | opt-assign | |
926 | | ;; EMPTY | |
927 | ; | |
928 | ||
929 | varnamelist | |
930 | : opt-ref varname varname-opt-initializer COMA varnamelist | |
b0fe992f | 931 | ( ,(cons (append $2 $3) $5) ) |
469d2149 | 932 | | opt-ref varname varname-opt-initializer |
b0fe992f | 933 | ( (append $2 $3) ) |
469d2149 CY |
934 | ; |
935 | ||
936 | ;; Klaus Berndl: Is necessary to parse stuff like | |
937 | ;; class list_of_facts : public list<fact>, public entity | |
938 | ;; and | |
939 | ;; list <shared_ptr<item> >::const_iterator l; | |
940 | ;; Parses also invalid(?) and senseless(?) c++-syntax like | |
941 | ;; symbol<template-spec>::symbol1<template-spec1>::test_iterator | |
942 | ;; but better parsing too much than to less | |
943 | namespace-symbol | |
944 | : symbol opt-template-specifier COLON COLON namespace-symbol | |
945 | ( (concat $1 "::" (car $5)) ) | |
946 | | symbol opt-template-specifier | |
947 | ( $1 ) | |
948 | ; | |
949 | ||
950 | ;; Don't pull an optional template specifier at the end of the | |
951 | ;; namespace symbol so that it can be picked up by the type. | |
952 | namespace-symbol-for-typeformbase | |
953 | : symbol opt-template-specifier COLON COLON namespace-symbol-for-typeformbase | |
954 | ( (concat $1 "::" (car $5)) ) | |
955 | | symbol | |
956 | ( $1 ) | |
957 | ; | |
958 | ;; namespace-symbol | |
959 | ;; : symbol COLON COLON namespace-symbol | |
960 | ;; ( (concat $1 "::" (car $4)) ) | |
961 | ;; | symbol | |
962 | ;; ( $1 ) | |
963 | ;; ; | |
964 | ||
965 | namespace-opt-class | |
966 | : symbol COLON COLON namespace-opt-class | |
967 | ( (concat $1 "::" (car $4)) ) | |
968 | ;; Klaus Berndl: We must recognize template-specifiers here so we can | |
969 | ;; parse correctly the method-implementations of template-classes | |
970 | ;; outside the template-class-declaration Example: | |
971 | ;; TemplateClass1<T>::method_1(...) | |
972 | | symbol opt-template-specifier COLON COLON | |
973 | ( $1 ) | |
974 | ; | |
975 | ||
976 | ;; Klaus Berndl: The opt-class of a func-decl must be able to | |
977 | ;; recognize opt-classes with namespaces, e.g. | |
978 | ;; Test1::Test2::classname:: | |
979 | opt-class | |
980 | : namespace-opt-class | |
981 | ( ,$1 ) | |
982 | | ;;EMPTY | |
983 | ( nil ) | |
984 | ; | |
985 | ||
986 | opt-destructor | |
987 | : TILDE | |
988 | ( t ) | |
989 | | ;;EMPTY | |
990 | ( nil ) | |
991 | ; | |
992 | ||
993 | arg-list | |
994 | : PAREN_BLCK knr-arguments | |
995 | ( ,$2 ) | |
996 | | PAREN_BLCK | |
997 | (EXPANDFULL $1 arg-sub-list) | |
998 | | VOID_BLCK | |
999 | ( ) | |
1000 | ; | |
1001 | ||
1002 | knr-varnamelist | |
1003 | : varname COMA knr-varnamelist | |
1004 | ( ,(cons $1 $3) ) | |
1005 | | varname | |
1006 | ( $1 ) | |
1007 | ; | |
1008 | ||
1009 | ||
1010 | knr-one-variable-decl | |
1011 | : declmods typeformbase cv-declmods knr-varnamelist | |
1012 | ( VARIABLE-TAG (nreverse $4) $2 nil | |
1013 | :constant-flag (if (member "const" (append $3)) t nil) | |
1014 | :typemodifiers (delete "const" $3) | |
1015 | ) | |
1016 | ; | |
1017 | ||
1018 | knr-arguments | |
1019 | : knr-one-variable-decl SEMICOLON knr-arguments | |
1020 | ( ,(append (semantic-expand-c-tag ,$1) ,$3) ) | |
1021 | | knr-one-variable-decl SEMICOLON | |
1022 | ( ,(semantic-expand-c-tag ,$1) ) | |
1023 | ; | |
1024 | ||
1025 | arg-sub-list | |
1026 | : variablearg | |
1027 | ( ,$1 ) | |
1028 | | PERIOD PERIOD PERIOD RPAREN | |
1029 | (VARIABLE-TAG "..." "vararg" nil) | |
1030 | | COMA | |
1031 | ( nil ) | |
1032 | | LPAREN | |
1033 | ( nil ) | |
1034 | | RPAREN | |
1035 | ( nil ) | |
1036 | ; | |
1037 | ||
1038 | operatorsym | |
1039 | : LESS LESS EQUAL | |
1040 | ( "<<=" ) | |
1041 | | GREATER GREATER EQUAL | |
1042 | ( ">>=" ) | |
1043 | | LESS LESS | |
1044 | ( "<<" ) | |
1045 | | GREATER GREATER | |
1046 | ( ">>" ) | |
1047 | | EQUAL EQUAL | |
1048 | ( "==" ) | |
1049 | | LESS EQUAL | |
1050 | ( "<=" ) | |
1051 | | GREATER EQUAL | |
1052 | ( ">=" ) | |
1053 | | BANG EQUAL | |
1054 | ( "!=" ) | |
1055 | | PLUS EQUAL | |
1056 | ( "+=" ) | |
1057 | | MINUS EQUAL | |
1058 | ( "-=" ) | |
1059 | | STAR EQUAL | |
1060 | ( "*=" ) | |
1061 | | DIVIDE EQUAL | |
1062 | ( "/=" ) | |
1063 | | MOD EQUAL | |
1064 | ( "%=" ) | |
1065 | | AMPERSAND EQUAL | |
1066 | ( "&=" ) | |
1067 | | OR EQUAL | |
1068 | ( "|=" ) | |
1069 | | MINUS GREATER STAR | |
1070 | ( "->*" ) | |
1071 | | MINUS GREATER | |
1072 | ( "->" ) | |
1073 | | PARENS | |
1074 | ( "()" ) | |
1075 | | BRACKETS | |
1076 | ( "[]" ) | |
1077 | | LESS | |
1078 | | GREATER | |
1079 | | STAR | |
1080 | | PLUS PLUS | |
1081 | ( "++" ) | |
1082 | | PLUS | |
1083 | | MINUS MINUS | |
1084 | ( "--" ) | |
1085 | | MINUS | |
1086 | | AMPERSAND AMPERSAND | |
1087 | ( "&&" ) | |
1088 | | AMPERSAND | |
1089 | | OR OR | |
1090 | ( "||" ) | |
1091 | | OR | |
1092 | | DIVIDE | |
1093 | | EQUAL | |
1094 | | BANG | |
1095 | | TILDE | |
1096 | | MOD | |
1097 | | COMA | |
1098 | ;; HAT EQUAL seems to have a really unpleasant result and | |
1099 | ;; breaks everything after it. Leave it at the end, though it | |
1100 | ;; doesn't seem to work. | |
1101 | | HAT EQUAL | |
1102 | ( "^=" ) | |
1103 | | HAT | |
1104 | ; | |
1105 | ||
1106 | functionname | |
1107 | : OPERATOR operatorsym | |
1108 | ( ,$2 ) | |
1109 | | semantic-list | |
1110 | ( EXPAND $1 function-pointer ) | |
1111 | | symbol | |
1112 | ( $1 ) | |
1113 | ; | |
1114 | ||
1115 | function-pointer | |
a60a2b6d DE |
1116 | : LPAREN STAR opt-symbol RPAREN |
1117 | ( (concat "*" ,(car $3)) ) | |
62a81506 CY |
1118 | | LPAREN symbol RPAREN |
1119 | ( $2 ) | |
469d2149 CY |
1120 | ; |
1121 | ||
1122 | fun-or-proto-end | |
1123 | : SEMICOLON | |
1124 | ( t ) | |
1125 | | semantic-list | |
1126 | ( nil ) | |
91af3942 | 1127 | ;; Here is an annoying feature of C++ pure virtual methods |
469d2149 CY |
1128 | | EQUAL ZERO SEMICOLON |
1129 | ( :pure-virtual-flag ) | |
1130 | | fun-try-end | |
1131 | ( nil ) | |
1132 | ; | |
1133 | ||
1134 | fun-try-end | |
1135 | : TRY opt-initializers BRACE_BLCK fun-try-several-catches | |
1136 | ( nil ) | |
1137 | ; | |
1138 | ||
1139 | fun-try-several-catches | |
1140 | : CATCH PAREN_BLCK BRACE_BLCK fun-try-several-catches | |
1141 | ( ) | |
1142 | | CATCH BRACE_BLCK fun-try-several-catches | |
1143 | ( ) | |
1144 | | ;; EMPTY | |
1145 | ( ) | |
1146 | ; | |
1147 | ||
1148 | type-cast | |
1149 | : semantic-list | |
1150 | ( EXPAND $1 type-cast-list ) | |
1151 | ; | |
1152 | ||
1153 | type-cast-list | |
1154 | : open-paren typeformbase close-paren | |
1155 | ; | |
1156 | ||
a60a2b6d DE |
1157 | opt-brackets-after-symbol |
1158 | : brackets-after-symbol | |
1159 | | ;; EMPTY | |
1160 | ; | |
1161 | ||
b0fe992f | 1162 | brackets-after-symbol |
469d2149 CY |
1163 | : PAREN_BLCK |
1164 | | BRACK_BLCK | |
469d2149 CY |
1165 | ; |
1166 | ||
1167 | multi-stage-dereference | |
a60a2b6d DE |
1168 | : namespace-symbol opt-brackets-after-symbol |
1169 | PERIOD multi-stage-dereference ;; method call | |
1170 | | namespace-symbol opt-brackets-after-symbol | |
1171 | MINUS GREATER multi-stage-dereference ;;method call | |
1172 | | namespace-symbol opt-brackets-after-symbol | |
1173 | PERIOD namespace-symbol opt-brackets-after-symbol | |
1174 | | namespace-symbol opt-brackets-after-symbol | |
1175 | MINUS GREATER namespace-symbol opt-brackets-after-symbol | |
b0fe992f | 1176 | | namespace-symbol brackets-after-symbol |
469d2149 CY |
1177 | ; |
1178 | ||
1179 | string-seq | |
1180 | : string string-seq | |
1181 | ( (concat $1 (car $2)) ) | |
1182 | | string | |
1183 | ( $1 ) | |
1184 | ; | |
1185 | ||
1186 | expr-start | |
1187 | : MINUS | |
1188 | | PLUS | |
1189 | | STAR | |
1190 | | AMPERSAND | |
1191 | ; | |
1192 | ||
1193 | expr-binop | |
1194 | : MINUS | |
1195 | | PLUS | |
1196 | | STAR | |
1197 | | DIVIDE | |
1198 | | AMPERSAND AMPERSAND | |
1199 | | AMPERSAND | |
1200 | | OR OR | |
1201 | | OR | |
b0fe992f | 1202 | | MOD |
469d2149 CY |
1203 | ;; There are more. |
1204 | ; | |
1205 | ||
1206 | ;; Use expression for parsing only. Don't actually return anything | |
1207 | ;; for now. Hopefully we can fix this later. | |
1208 | expression | |
1209 | : unaryexpression expr-binop unaryexpression | |
1210 | ( (identity start) (identity end) ) | |
1211 | | unaryexpression | |
1212 | ( (identity start) (identity end) ) | |
1213 | ; | |
1214 | ||
1215 | unaryexpression | |
1216 | : number | |
1217 | | multi-stage-dereference | |
1218 | | NEW multi-stage-dereference | |
1219 | | NEW builtintype-types semantic-list | |
b0fe992f | 1220 | | symbol |
469d2149 CY |
1221 | ;; Klaus Berndl: C/C++ allows sequences of strings which are |
1222 | ;; concatenated by the precompiler to one string | |
1223 | | string-seq | |
1224 | | type-cast expression ;; A cast to some other type | |
1225 | ;; Casting the results of one expression to something else. | |
1226 | | semantic-list expression | |
1227 | | semantic-list | |
1228 | | expr-start expression | |
1229 | ; | |
1230 | ||
62f43d66 | 1231 | ;;; c.by ends here |