Grammar bug fixes from CEDET upstream.
[bpt/emacs.git] / admin / grammars / c.by
CommitLineData
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
214declaration
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
226codeblock
227 : define
228 | codeblock-var-or-fun
229 | type ;; type is less likely to be used here.
230 | using
231 ;
232
233extern-c-contents
234 : open-paren
235 ( nil )
236 | declaration
237 | close-paren
238 ( nil )
239 ;
240
241extern-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
258macro
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.
268define
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
291unionparts
292 : semantic-list
293 (EXPANDFULL $1 classsubparts)
294 ;
295
296opt-symbol
297 : symbol
298 | ;;EMPTY
299 ;
300
301;; @todo - support 'friend' construct.
302classsubparts
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
322opt-class-parents
323 : COLON class-parents opt-template-specifier
324 ( $2 )
325 | ;;EMPTY
326 ( )
327 ;
328
329one-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
336class-parents
337 : one-class-parent COMA class-parents
338 ( ,(cons ,$1 $3 ) )
339 | one-class-parent
340 ( $1 )
341 ;
342
343opt-class-declmods
344 : class-declmods opt-class-declmods
345 ( nil )
346 | ;;EMPTY
347 ;
348
349class-declmods
350 : VIRTUAL
351 ;
352
353class-protection
354 : PUBLIC
355 | PRIVATE
356 | PROTECTED
357 ;
358
359opt-class-protection
360 : class-protection
361 ( ,$1 )
362 | ;;EMPTY - Same as private
363 ( "unspecified" )
364 ;
365
366namespaceparts
367 : semantic-list
368 (EXPANDFULL $1 namespacesubparts)
369 ;
370
371namespacesubparts
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
391enumparts
392 : semantic-list
393 (EXPANDFULL $1 enumsubparts)
394 ;
395
396enumsubparts
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
407opt-name
408 : symbol
409 | ;;EMPTY
410 ( "" )
411 ;
412
413typesimple
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
442typedef-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!
451typedefname
452 : opt-stars symbol opt-bits opt-array
453 ( $1 $2 )
454 ;
455
456struct-or-class
457 : STRUCT
458 | CLASS
459 ;
460
461type
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
480using
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.
487usingname
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
494template
495 : TEMPLATE template-specifier opt-friend template-definition
496 ( ,(semantic-c-reconstitute-template $4 ,$2) )
497 ;
498
499opt-friend
500 : FRIEND
501 | ;;EMPTY
502 ;
503
504opt-template-specifier
505 : template-specifier
506 ( ,$1 )
507 | ;;EMPTY
508 ( )
509 ;
510
511template-specifier
512 : LESS template-specifier-types GREATER
513 ( ,$2 )
514 ;
515
516template-specifier-types
517 : template-var template-specifier-type-list
518 ( ,(cons ,$1 ,$2 ) )
519 | ;;EMPTY
520 ;
521
522template-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
543template-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
570opt-template-equal
571 : EQUAL symbol LESS template-specifier-types GREATER
572 ( $2 )
573 | EQUAL symbol
574 ( $2 )
575 | ;;EMPTY
576 ( )
577 ;
578
579template-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
600template-definition
601 : type
602 ( ,$1 )
603 | var-or-fun
604 ( ,$1 )
605 ;
606
607opt-stars
608 : STAR opt-starmod opt-stars
609 ( (1+ (car $3)) )
610 | ;;EMPTY
611 ( 0 )
612 ;
613
614opt-starmod
615 : STARMOD opt-starmod
616 ( ,(cons (,car ,$1) $2) )
617 | ;;EMPTY
618 ()
619 ;
620
621STARMOD
622 : CONST
623 ;
624
625declmods
626 : DECLMOD declmods
627 ( ,(cons ,(car ,$1) $2 ) )
628 | DECLMOD
629 ( ,$1 )
630 | ;;EMPTY
631 ()
632 ;
633
634DECLMOD
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
654metadeclmod
655 : METADECLMOD
656 ()
657 | ;;EMPTY
658 ()
659 ;
660
661CVDECLMOD
662 : CONST
663 | VOLATILE
664 ;
665
666cv-declmods
667 : CVDECLMOD cv-declmods
668 ( ,(cons ,(car ,$1) $2 ) )
669 | CVDECLMOD
670 ( ,$1 )
671 | ;;EMPTY
672 ()
673 ;
674
675METADECLMOD
676 : VIRTUAL
677 | MUTABLE
678 ;
679
680;; C++: A type can be modified into a reference by "&"
681opt-ref
682 : AMPERSAND
683 ( 1 )
684 | ;;EMPTY
685 ( 0 )
686 ;
687
688typeformbase
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
710signedmod
711 : UNSIGNED
712 | SIGNED
713 ;
714
715;; Klaus Berndl: builtintype-types was builtintype
716builtintype-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
738builtintype
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...
757codeblock-var-or-fun
758 : declmods typeformbase declmods
759 opt-ref var-or-func-decl
760 ( ,(semantic-c-reconstitute-token ,$5 $1 $2 ) )
761 ;
762
763var-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
777var-or-func-decl
778 : func-decl
779 ( ,$1 )
780 | var-decl
781 ( ,$1 )
782 ;
783
784func-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
813var-decl
814 : varnamelist SEMICOLON
815 ( $1 'variable )
816 ;
817
818opt-under-p
819 : UNDERP
820 ( nil )
821 | UNDERUNDERP
822 ( nil )
823 | ;;EMPTY
824 ;
825
826;; Klaus Berndl: symbol -> namespace-symbol
827opt-initializers
828 : COLON namespace-symbol semantic-list opt-initializers
829 | COMA namespace-symbol semantic-list opt-initializers
830 | ;;EMPTY
831 ;
832
833opt-post-fcn-modifiers
834 : post-fcn-modifiers opt-post-fcn-modifiers
835 ( ,(cons ,$1 $2) )
836 | ;;EMPTY
837 ( nil )
838 ;
839
840post-fcn-modifiers
841 : REENTRANT
842 | CONST
843 ;
844
845opt-throw
846 : THROW semantic-list
847 ( EXPAND $2 throw-exception-list )
848 | ;;EMPTY
849 ;
850
851;; Is this true? I don't actually know.
852throw-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
865opt-bits
866 : COLON number
867 ( $2 )
868 | ;;EMPTY
869 ( nil )
870 ;
871
872opt-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
881opt-assign
882 : EQUAL expression
883 ( $2 )
884 | ;;EMPTY
885 ( nil )
886 ;
887
888opt-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.
896varname
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!
903variablearg
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
912variablearg-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
923varname-opt-initializer
924 : semantic-list
925 | opt-assign
926 | ;; EMPTY
927 ;
928
929varnamelist
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
943namespace-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.
952namespace-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
965namespace-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::
979opt-class
980 : namespace-opt-class
981 ( ,$1 )
982 | ;;EMPTY
983 ( nil )
984 ;
985
986opt-destructor
987 : TILDE
988 ( t )
989 | ;;EMPTY
990 ( nil )
991 ;
992
993arg-list
994 : PAREN_BLCK knr-arguments
995 ( ,$2 )
996 | PAREN_BLCK
997 (EXPANDFULL $1 arg-sub-list)
998 | VOID_BLCK
999 ( )
1000 ;
1001
1002knr-varnamelist
1003 : varname COMA knr-varnamelist
1004 ( ,(cons $1 $3) )
1005 | varname
1006 ( $1 )
1007 ;
1008
1009
1010knr-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
1018knr-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
1025arg-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
1038operatorsym
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
1106functionname
1107 : OPERATOR operatorsym
1108 ( ,$2 )
1109 | semantic-list
1110 ( EXPAND $1 function-pointer )
1111 | symbol
1112 ( $1 )
1113 ;
1114
1115function-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
1122fun-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
1134fun-try-end
1135 : TRY opt-initializers BRACE_BLCK fun-try-several-catches
1136 ( nil )
1137 ;
1138
1139fun-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
1148type-cast
1149 : semantic-list
1150 ( EXPAND $1 type-cast-list )
1151 ;
1152
1153type-cast-list
1154 : open-paren typeformbase close-paren
1155 ;
1156
a60a2b6d
DE
1157opt-brackets-after-symbol
1158 : brackets-after-symbol
1159 | ;; EMPTY
1160 ;
1161
b0fe992f 1162brackets-after-symbol
469d2149
CY
1163 : PAREN_BLCK
1164 | BRACK_BLCK
469d2149
CY
1165 ;
1166
1167multi-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
1179string-seq
1180 : string string-seq
1181 ( (concat $1 (car $2)) )
1182 | string
1183 ( $1 )
1184 ;
1185
1186expr-start
1187 : MINUS
1188 | PLUS
1189 | STAR
1190 | AMPERSAND
1191 ;
1192
1193expr-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.
1208expression
1209 : unaryexpression expr-binop unaryexpression
1210 ( (identity start) (identity end) )
1211 | unaryexpression
1212 ( (identity start) (identity end) )
1213 ;
1214
1215unaryexpression
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