Changes in / [a1e67dd:f0121d7]


Ignore:
Files:
6 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • doc/LaTeXmacros/common.tex

    ra1e67dd rf0121d7  
    11%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
    2 %%
     2%% 
    33%% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    44%%
    55%% The contents of this file are covered under the licence agreement in the
    66%% file "LICENCE" distributed with Cforall.
    7 %%
    8 %% common.tex --
    9 %%
     7%% 
     8%% common.tex -- 
     9%% 
    1010%% Author           : Peter A. Buhr
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    … …  
    4141\newcommand{\CCeleven}{\rm C\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
    4242\newcommand{\Celeven}{C11\xspace}               % C11 symbolic name
    43 \newcommand{\Csharp}{\rm C\hbox{\#}\xspace} % C# symbolic name
    44 
    4543
    4644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    … …  
    126124\newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
    127125
    128 % inline text and code index (cannot use �)
     126% inline text and code index (cannot use ©)
    129127\newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
    130 % code index (cannot use �)
     128% code index (cannot use ©)
    131129\newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
    132130
    … …  
    228226
    229227% CFA programming language, based on ANSI C (with some gcc additions)
    230 \lstdefinelanguage{Pseudo}{
    231         morekeywords={string,uint,int,bool,float},%
    232         sensitive=true,%
    233         morecomment=[l]{//},%
    234         morecomment=[s]{/*}{*/},%
    235         morestring=[b]',%
    236         morestring=[b]",%
    237         morestring=[s]{`}{`},%
     228\lstdefinelanguage{CFA}[ANSI]{C}{
     229        morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
     230                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
     231                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
     232                _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
    238233}%
    239234
    240235\lstset{
    241 language=Pseudo,
     236language=CFA,
    242237columns=fullflexible,
    243 basicstyle=\linespread{0.9}\tt\small,           % reduce line spacing and use typewriter font
    244 stringstyle=\sf\color{Mahogany},                        % use sanserif font
    245 commentstyle=\itshape\color{OliveGreen},                % green and italic comments
    246 tabsize=4,                                                      % 4 space tabbing
     238basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
     239stringstyle=\tt,                                                % use typewriter font
     240tabsize=4,                                                              % 4 space tabbing
    247241xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
    248 extendedchars=true,                                     % allow ASCII characters in the range 128-255
    249 escapechar=§,                                           % escape to latex in CFA code
     242extendedchars=true,                                             % allow ASCII characters in the range 128-255
     243escapechar=§,                                                   % escape to latex in CFA code
    250244mathescape=true,                                                % allow $...$ LaTeX math escapes in code
    251 %keepspaces=true,                                               %
     245%keepspaces=true,                                               % 
    252246showstringspaces=false,                                 % do not show spaces with cup
    253 showlines=true,                                         % show blank lines at end of code
    254 aboveskip=4pt,                                          % spacing above/below code block
     247showlines=true,                                                 % show blank lines at end of code
     248aboveskip=4pt,                                                  % spacing above/below code block
    255249belowskip=3pt,
    256250moredelim=**[is][\color{red}]{®}{®},    % red highlighting
    … …  
    259253moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
    260254% replace/adjust listing characters that look bad in sanserif
    261 literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 {©}{{\"u}}1
     255literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
    262256        {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
    263257        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2,
    264258}%
    265259
    266 % CFA programming language, based on ANSI C (with some gcc additions)
    267 \lstdefinelanguage{CFA}[ANSI]{C}{
    268         morekeywords=[1]{_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
    269                 _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    270                 fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
    271                 _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
    272         morekeywords=[2]{mutex,nomutex,thread,wait,signal,accept,monitor}
    273 }%
    274 
    275 \lstset{
    276 language=CFA,
    277 columns=fullflexible,
    278 basicstyle=\linespread{0.9}\tt\small,           % reduce line spacing and use typewriter font
    279 keywordstyle=[2]\color{blue},                           % second set of keywords for concurency
    280 stringstyle=\sf\color{Mahogany},                        % use sanserif font
    281 commentstyle=\itshape\color{OliveGreen},                % green and italic comments
    282 tabsize=4,                                                      % 4 space tabbing
    283 xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
    284 extendedchars=true,                                     % allow ASCII characters in the range 128-255
    285 escapechar=§,                                           % escape to latex in CFA code
    286 mathescape=true,                                                % allow $...$ LaTeX math escapes in code
    287 %keepspaces=true,                                               %
    288 showstringspaces=false,                                 % do not show spaces with cup
    289 showlines=true,                                         % show blank lines at end of code
    290 aboveskip=4pt,                                          % spacing above/below code block
    291 belowskip=3pt,
    292 moredelim=**[is][\color{red}]{®}{®},    % red highlighting
    293 moredelim=**[is][\color{blue}]{ß}{ß},   % blue highlighting
    294 moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting
    295 moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
    296 % replace/adjust listing characters that look bad in sanserif
    297 literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 {©}{{\"u}}1
    298         {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
    299         {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2,
    300 }%
    301 
    302260\lstMakeShortInline©    % single-character for \lstinline
    303 
    304261
    305262\let\Oldthebibliography\thebibliography

  • doc/proposals/concurrency/Makefile

    ra1e67dd rf0121d7  
    1212
    1313FIGURES = ${addsuffix .tex, \
    14         monitor \
    15         ext_monitor \
    1614}
    1715
    … …  
    3432
    3533clean :
    36         rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist *.acn *.acr *.alg \
     34        rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist \
    3735                ${FIGURES} ${PICTURES} ${PROGRAMS} ${GRAPHS} ${basename ${DOCUMENT}}.ps ${DOCUMENT}
    3836
    … …  
    6058        # Run again to get index title into table of contents
    6159        ${LaTeX} ${basename $@}.tex
    62         -./bump_ver.sh
    6360        ${LaTeX} ${basename $@}.tex
    6461
    … …  
    7976        fig2dev -L pstex_t -p $@ $< > $@_t
    8077
    81 
    8278# Local Variables: #
    8379# compile-command: "make" #

  • doc/proposals/concurrency/concurrency.tex

    ra1e67dd rf0121d7  
    11% requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
    22
    3 % inline code ©...© (copyright symbol) emacs: C-q M-)
    4 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
    5 % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
    6 % green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
    7 % LaTex escape §...§ (section symbol) emacs: C-q M-'
    8 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
     3% inline code �...� (copyright symbol) emacs: C-q M-)
     4% red highlighting �...� (registered trademark symbol) emacs: C-q M-.
     5% blue highlighting �...� (sharp s symbol) emacs: C-q M-_
     6% green highlighting �...� (cent symbol) emacs: C-q M-"
     7% LaTex escape �...� (section symbol) emacs: C-q M-'
     8% keyword escape �...� (pilcrow symbol) emacs: C-q M-^
    99% math escape $...$ (dollar symbol)
    1010
    … …  
    2424\usepackage{graphicx}
    2525\usepackage{tabularx}
    26 \usepackage[acronym]{glossaries}
     26\usepackage{glossaries}
    2727\usepackage{varioref}                                                           % extended references
    2828\usepackage{inconsolata}
    … …  
    3333\usepackage[usenames]{color}
    3434\usepackage[pagewise]{lineno}
    35 \usepackage{fancyhdr}
    3635\renewcommand{\linenumberfont}{\scriptsize\sffamily}
    3736\input{common}                                          % bespoke macros used in the document
    3837\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
    3938\usepackage{breakurl}
    40 
    41 \usepackage{tikz}
    42 \def\checkmark{\tikz\fill[scale=0.4](0,.35) -- (.25,0) -- (1,.7) -- (.25,.15) -- cycle;}
    4339
    4440\renewcommand{\UrlFont}{\small\sf}
    … …  
    6258\newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace}
    6359\newcommand{\code}[1]{\lstinline{#1}}
    64 \newcommand{\pseudo}[1]{\lstinline[language=Pseudo]{#1}}
    6560
    6661\input{glossary}
    … …  
    7267\setcounter{secnumdepth}{3}                             % number subsubsections
    7368\setcounter{tocdepth}{3}                                % subsubsections in table of contents
    74 % \linenumbers                                            % comment out to turn off line numbering
    7569\makeindex
    76 \pagestyle{fancy}
    77 \fancyhf{}
    78 \cfoot{\thepage}
    79 \rfoot{v\input{version}}
    8070
    8171%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    … …  
    9181\maketitle
    9282\section{Introduction}
    93 This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible core is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level construct as the basis of the concurrency in \CFA.
    94 Indeed, for highly productive parallel programming high-level approaches are much more popular\cite{HPP:Study}. Examples are task based parallelism, message passing, implicit threading.
    95 
    96 There are actually two problems that need to be solved in the design of the concurrency for a language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization while parallelism tools are more about performance, cost and resource utilization.
     83This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build "higher level" features. The simplest possible core is a thread and a lock but this low level approach is hard to master. An easier approach for users is be to support higher level construct as the basis of the concurrency in \CFA.
     84Indeed, for higly productive parallel programming high-level approaches are much more popular\cite{HPP:Study}. Examples are task based parallelism, message passing, implicit threading.
     85
     86There are actually two problems that need to be solved in the design of the concurrency for a language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization while parallelism tools are more about performance, cost and ressource utilisation.
    9787
    9888\section{Concurrency}
    99 Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared-state (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cite{Akka}). In these paradigms, interaction among concurrent objects rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This project proposes Monitors\cite{Hoare74} as the core concurrency construct.
    100 \\
     89Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared state completely (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cit). In the paradigms, interaction between concurrent objects rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages these approaches entail a clear distinction between concurrent and non concurrent paradigms. Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective at their jobs. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This paper proposes Monitors\cit as the core concurrency construct.
    10190
    10291Finally, an approach that is worth mentionning because it is gaining in popularity is transactionnal memory\cite{Dice10}. However, the performance and feature set is currently too restrictive to be possible to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA.
    10392
    104 \subsection{Monitors}
    105 A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java\cite{Java} or \uC\cite{uC++book} but does not strictly require OOP semantics. The only requirements is the ability to declare a handle to a shared object and a set of routines that act on it :
     93\section{Monitors}
     94A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java\cite{Java} or \uC\cite{uC++book} but does not strictly require OOP semantics. The only requirements is to be able to declare a handle to a shared object and a set of routines that act on it :
    10695\begin{lstlisting}
    10796        typedef /*some monitor type*/ monitor;
    … …  
    114103\end{lstlisting}
    115104
    116 \subsubsection{Call semantics} \label{call}
    117 The above example of monitors already displays some of their intrinsic caracteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable.
    118 \\
    119 
    120 Another aspect to consider is when a monitor acquires its mutual exclusion. Indeed, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual exclusion on entry. Examples of this can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following example :
     105\subsection{Call semantics} \label{call}
     106The above example of monitors already displays some of their intrinsic caracteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because since at their core, monitors are simply implicit mutual exclusion objects (locks) and copying semantics of these is ill defined. Therefore, monitors are implicitly non-copyable.
     107
     108Another aspect to consider is when a monitor acquires its mutual exclusion. Indeed, a monitor may need to be passed to helper routines that do not acquire the monitor mutual exclusion on entry. Examples of this can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following example :
    121109
    122110\begin{lstlisting}
    123111        mutex struct counter_t { /*...*/ };
    124112
    125         void ?{}(counter_t & nomutex this);
     113        void ?{}(counter_t & mutex this);
    126114        int ++?(counter_t & mutex this);
    127         void ?{}(Int * this, counter_t & mutex cnt);
    128 \end{lstlisting}
    129 *semantics of the declaration of \code{mutex struct counter_t} are discussed in details in section \ref{data}
    130 \\
    131 
    132 This example is of a monitor implementing an atomic counter. Here, the constructor uses the \code{nomutex} keyword to signify that it does not acquire the coroutine mutual exclusion when constructing. This is because object not yet constructed should never be shared and therefore do not require mutual exclusion. The prefix increment operator
    133 uses \code{mutex} to protect the incrementing process from race conditions. Finally, we have a conversion operator from \code{counter_t} to \code{Int}. This conversion may or may not require the \code{mutex} key word depending whether or not reading an \code{Int} is an atomic operation or not.
    134 \\
     115        void ?{}(int * this, counter_t & mutex cnt);
     116
     117        bool is_zero(counter_t & nomutex this) {
     118                int val = this;
     119                return val == 0;
     120        }
     121\end{lstlisting}
     122*semantics of the declaration of \code{mutex struct counter_t} will be discussed in details in \ref{data}
     123
     124This is an example of a monitor used as safe(ish) counter for concurrency. This API, which offers the prefix increment operator and a conversion operator to \code{int}, guarantees that reading the value (by converting it to \code{int}) and incrementing it are mutually exclusive. Note that the \code{is_zero} routine uses the \code{nomutex} keyword. Indeed, since reading the value is already atomic, there is no point in maintaining the mutual exclusion once the value is copied locally (in the variable \code{val} ).
    135125
    136126Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. If there were a meaning to routine \code{void foo(counter_t & this)} then one could argue that it should be to default to the safest option : \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that this is the more "normal" behavior, \code{nomutex} effectively stating explicitly that "this routine has nothing special". An other alternative is to make one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being more clearly self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach will be used for the sake of clarity.
    137 \\
    138127
    139128Regardless of which keyword is kept, it is important to establish when mutex/nomutex may be used depending on type parameters.
    140129\begin{lstlisting}
    141         int f1(monitor & mutex m);
    142         int f2(const monitor & mutex m);
    143         int f3(monitor ** mutex m);
    144         int f4(monitor *[] mutex m);
    145         int f5(graph(monitor*) & mutex m);
    146 \end{lstlisting}
    147 
    148 The problem is to indentify which object(s) should be acquired. Furthermore we also need to acquire each objects only once. In case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entering. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object will be acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths aren't necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5} which uses a custom graph of monitors. To keep everyone as sane as possible\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter (ignoring potential qualifiers and indirections).
    149 
    150 \subsubsection{Data semantics} \label{data}
     130        int f01(monitor & mutex m);
     131        int f02(const monitor & mutex m);
     132        int f03(monitor * mutex m);
     133        int f04(monitor * mutex * m);
     134        int f05(monitor ** mutex m);
     135        int f06(monitor[10] mutex m);
     136        int f07(monitor[] mutex m);
     137        int f08(vector(monitor) & mutex m);
     138        int f09(list(monitor) & mutex m);
     139        int f10([monitor*, int] & mutex m);
     140        int f11(graph(monitor*) & mutex m);
     141\end{lstlisting}
     142
     143For the first few routines it seems to make sense to support the mutex keyword for such small variations. The difference between pointers and reference (\code{f01} vs \code{f03}) or const and non-const (\code{f01} vs \code{f02}) has no significance to mutual exclusion. It may not always make sense to acquire the monitor when extra dereferences (\code{f04}, \code{f05}) are added but it is still technically feasible and the present of the explicit mutex keywork does make it very clear of the user's intentions. Passing in a known-sized array(\code{f06}) is also technically feasible but is close to the limits. Indeed, the size of the array is not actually enforced by the compiler and if replaced by a variable-sized array (\code{f07}) or a higher-level container (\code{f08}, \code{f09}) it becomes much more complex to properly acquire all the locks needed for such a complex critical section. This implicit acquisition also poses the question of what qualifies as a container. If the mutex keyword is supported on monitors stored inside of other types it can quickly become complex and unclear which monitor should be acquired and when. The extreme example of this is \code{f11} which takes a possibly cyclic graph of pointers to monitors. With such a routine signature the intuition of which monitors will be acquired on entry is lost\cite{Chicken}. Where to draw the lines is up for debate but it seems reasonnable to consider \code{f03} as accepted and \code{f06} as rejected.
     144
     145\subsection{Data semantics} \label{data}
    151146Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appripriate protection. For example here is a more fleshed-out version of the counter showed in \ref{call}:
    152147\begin{lstlisting}
    … …  
    155150        };
    156151
    157         void ?{}(counter_t & nomutex this) {
     152        void ?{}(counter_t & mutex this) {
    158153                this.cnt = 0;
    159154        }
    … …  
    170165Thread 1 & Thread 2 \\
    171166\begin{lstlisting}
    172         void f(counter_t & mutex c) {
     167        void main(counter_t & mutex c) {
    173168                for(;;) {
    174                         sout | (int)c | endl;
     169                        int count = c;
     170                        sout | count | endl;
    175171                }
    176172        }
    177173\end{lstlisting} &\begin{lstlisting}
    178         void g(counter_t & mutex c) {
     174        void main(counter_t & mutex c) {
    179175                for(;;) {
    180176                        ++c;
    … …  
    198194\end{lstlisting}
    199195
    200 This code acquires both locks before entering the critical section. In practice, writing multi-locking routines that can not lead to deadlocks can be very tricky. Having language level support for such feature is therefore a significant asset for \CFA. However, this does have significant repercussions relating to scheduling (see \ref{insched} and \ref{extsched}). Furthermore, the ability to acquire multiple monitors at the same time does incur a significant pitfall even without looking into scheduling. For example :
     196This code acquires both locks before entering the critical section. In practice, writing multi-locking routines that can lead to deadlocks can be very tricky. Having language level support for such feature is therefore a significant asset for \CFA. However, as the this proposal shows, this does have significant repercussions relating to scheduling (see \ref{insched} and \ref{extsched}). The ability to acquire multiple monitors at the same time does incur a significant pitfall even without looking into scheduling. For example :
    201197\begin{lstlisting}
    202198        void foo(A & mutex a, B & mutex a) {
    … …  
    217213\end{lstlisting}
    218214
    219 Recursive mutex routine calls are allowed in \CFA but if not done carefully it can lead to nested monitor call problems\cite{Lister77}. These problems which are a specific  implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{bar} but explicit ordering in the case of \code{baz}. This subtle mistake can mean that calling these two functions concurrently will lead to deadlocks, depending on the implicit ordering matching the explicit ordering. As shown on several occasion\cit, there isn't really any solutions to this problem, users simply need to be carefull when acquiring multiple monitors at the same time.
    220 
    221 \subsubsection{Implementation Details: Interaction with polymorphism}
    222 At first glance, interaction between monitors and \CFA's concept of polymorphism seem complexe to support. However, it can be reasoned that entry-point locking can solve most of the issues that could be present with polymorphism.
    223 
    224 First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore the main question is how to support \code{dtype} polymorphism. We must remember that monitors' main purpose is to ensure mutual exclusion when accessing shared data. This implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handle incomplete types (by definition) no \code{dtype} polymorphic routine can access shared data since the data would require knowledge about the type. Therefore the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. With callsite-locking, this would require significant amount of work since any \code{dtype} routine could have to obtain some lock before calling a routine. However, with entry-point-locking calling a monitor routine becomes exactly the same as calling it from anywhere else.
    225 
    226 \subsection{Internal scheduling} \label{insched}
     215TODO: dig further into monitor order aquiring
     216
     217Thoughs : calls to \code{baz} and \code{bar} are definitely incompatible because they explicitly acquire locks in reverse order and therefore are explicitly asking for a deadlock. The best that can be done in this situatuin is to detect the deadlock. The case of implicit ordering is less clear because in the case of monitors the runtime system \textit{may} be smart enough to figure out that someone is waiting with explicit ordering... maybe.
     218
     219\subsubsection{Internal scheduling} \label{insched}
    227220Monitors should also be able to schedule what threads access it as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and wait for them to be signaled. Here is a simple example of such a technique :
    228221
    … …  
    243236\end{lstlisting}
    244237
    245 Here routine \code{foo} waits on the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This semantic can easily be extended to multi-monitor calls by offering the same guarantee.
     238Here routine \code{foo} waits on the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This can easily be extended to multi-monitor calls by offering the same guarantee.
    246239
    247240\begin{center}
    … …  
    270263\end{center}
    271264
    272 A direct extension of the single monitor semantics would be to release all locks when waiting and transferring ownership of all locks when signalling. However, for the purpose of synchronization it may be usefull to only release some of the locks but keep others. On the technical side, partially releasing lock is feasible but from the user perspective a choice must be made for the syntax of this feature. It is possible to do without any extra syntax by relying on order of acquisition (Note that here the use of helper routines is irrelevant, only routines the acquire mutual exclusion have an impact on internal scheduling):
     265A direct extension of the single monitor semantics would be to release all locks when waiting and transferring ownership of all locks when signalling. However, for the purpose of synchronization it may be usefull to only release some of the locks but keep others. On the technical side, partially releasing lock is feasible but from the user perspective a choice must be made for the syntax of this feature. It is possible to do without any extra syntax by relying on order of acquisition :
    273266
    274267\begin{center}
    … …  
    277270\hline
    278271\begin{lstlisting}
    279 condition e;
    280 
    281272void foo(monitor & mutex a,
    282273         monitor & mutex b) {
    283         wait(e);
     274        wait(a.e);
    284275}
    285276
    … …  
    291282foo(a,b);
    292283\end{lstlisting} &\begin{lstlisting}
    293 condition e;
    294 
    295284void bar(monitor & mutex a,
    296285         monitor & nomutex b) {
    … …  
    300289void foo(monitor & mutex a,
    301290         monitor & mutex b) {
    302         wait(e);
     291        wait(a.e);
    303292}
    304293
    305294bar(a, b);
    306295\end{lstlisting} &\begin{lstlisting}
    307 condition e;
    308 
    309296void bar(monitor & mutex a,
    310297         monitor & nomutex b) {
    … …  
    314301void baz(monitor & nomutex a,
    315302         monitor & mutex b) {
    316         wait(e);
     303        wait(a.e);
    317304}
    318305
    … …  
    323310
    324311This can be interpreted in two different ways :
    325 \begin{flushleft}
    326312\begin{enumerate}
    327         \item \code{wait} atomically releases the monitors acquired by the inner-most routine, \underline{ignoring} nested calls.
    328         \item \code{wait} atomically releases the monitors acquired by the inner-most routine, \underline{considering} nested calls.
     313        \item \code{wait} atomically releases the monitors \underline{theoretically} acquired by the inner-most mutex routine.
     314        \item \code{wait} atomically releases the monitors \underline{actually} acquired by the inner-most mutex routine.
    329315\end{enumerate}
    330 \end{flushleft}
    331 While the difference between these two is subtle, it has a significant impact. In the first case it means that the calls to \code{foo} would behave the same in Context 1 and 2. This semantic would also mean that the call to \code{wait} in routine \code{baz} would only release \code{monitor b}. While this may seem intuitive with these examples, it does have one significant implication, it creates a strong distinction between acquiring multiple monitors in sequence and acquiring the same monitors simulatenously, i.e. :
     316While the difference between these two is subtle, it has a significant impact. In the first case it means that the calls to \code{foo} would behave the same in Context 1 and 2. This semantic would also mean that the call to \code{wait} in routine \code{baz} would only release \code{monitor b}. While this may seem intuitive with these examples, it does have one significant implication, it creates a strong distinction between acquiring multiple monitors in sequence and acquiring the same monitors simulatenously.
    332317
    333318\begin{center}
    … …  
    349334\end{center}
    350335
    351 This is not intuitive because even if both methods display the same monitors state both inside and outside the critical section respectively, the behavior is different. Furthermore, the actual acquiring order will be exaclty the same since acquiring a monitor from inside its mutual exclusion is a no-op. This means that even if the data and the actual control flow are the same using both methods, the behavior of the \code{wait} will be different. The alternative is option 2, that is releasing acquired monitors, \underline{considering} nesting. This solves the issue of having the two acquiring method differ at the cost of making routine \code{foo} behave differently depending on from which context it is called (Context 1 or 2). Indeed in Context 2, routine \code{foo} actually behaves like routine \code{baz} rather than having the same behavior than in Context 1. The fact that both implicit approaches can be unintuitive depending on the perspective may be a sign that the explicit approach is superior. For this reason this \CFA does not support implicit monitor releasing and uses explicit semantics.
     336This is not intuitive because even if both methods will display the same monitors state both inside and outside the critical section respectively, the behavior is different. Furthermore, the actual acquiring order will be exaclty the same since acquiring a monitor from inside its mutual exclusion is a no-op. This means that even if the data and the actual control flow are the same using both methods, the behavior of the \code{wait} will be different. The alternative is option 2, that is releasing \underline{actually} acquired monitors. This solves the issue of having the two acquiring method differ at the cost of making routine \code{foo} behave differently depending on from which context it is called (Context 1 or 2). Indeed in Context 2, routine \code{foo} will actually behave like routine \code{baz} rather than having the same behavior than in context 1. The fact that both implicit approaches can be unintuitive depending on the perspective may be a sign that the explicit approach is superior.
    352337\\
    353338
    … …  
    426411\\
    427412
    428 All these cases have their pros and cons. Case 1 is more distinct because it means programmers need to be carefull about where the condition is initialized as well as where it is used. On the other hand, it is very clear and explicitly states which monitor is released and which monitor stays acquired. This is similar to Case 2, which releases only the monitors explictly listed. However, in Case 2, calling the \code{wait} routine instead of the \code{waitRelease} routine releases all the acquired monitor. The Case 3 is an improvement on that since it releases all the monitors except those specified. The result is that the \code{wait} routine can be written as follows :
     413All these cases have there pros and cons. Case 1 is more distinct because it means programmers need to be carefull about where the condition was initialized as well as where it is used. On the other hand, it is very clear and explicit which monitor will be released and which monitor will stay acquired. This is similar to Case 2, which releases only the monitors explictly listed. However, in Case 2, calling the \code{wait} routine instead of the \code{waitRelease} routine will release all the acquired monitor. The Case 3 is an improvement on that since it releases all the monitors except those specified. The result is that the \code{wait} routine can be written as follows :
    429414\begin{lstlisting}
    430415void wait(condition & cond) {
    … …  
    434419This alternative offers nice and consistent behavior between \code{wait} and \code{waitHold}. However, one large pitfall is that mutual exclusion can now be violated by calls to library code. Indeed, even if the following example seems benign there is one significant problem :
    435420\begin{lstlisting}
    436 monitor global;
    437 
    438 extern void doStuff(); //uses global
     421extern void doStuff();
    439422
    440423void foo(monitor & mutex m) {
    … …  
    443426        //...
    444427}
    445 
    446 foo(global);
    447 \end{lstlisting}
    448 
    449 Indeed, if Case 2 or 3 are chosen it any code can violate the mutual exclusion of the calling code by issuing calls to \code{wait} or \code{waitHold} in a nested monitor context. Case 2 can be salvaged by removing the \code{wait} routine from the API but Case 3 cannot prevent users from calling \code{waitHold(someCondition, [])}. For this reason the syntax proposed in Case 3 is rejected. Note that the syntax proposed in case 1 and 2 are not exclusive. Indeed, by supporting two types of condition both cases can be supported :
     428\end{lstlisting}
     429
     430Indeed, if Case 2 or 3 are chosen it any code can violate the mutual exclusion of calling code by issuing calls to \code{wait} or \code{waitHold} in a nested monitor context. Case 2 can be salvaged by removing the \code{wait} routine from the API but Case 3 cannot prevent users from calling \code{waitHold(someCondition, [])}. For this reason the syntax proposed in Case 3 is rejected. Note that syntaxes proposed in case 1 and 2 are not exclusive. Indeed, by supporting two types of condition as follows both cases can be supported :
    450431\begin{lstlisting}
    451432struct condition { /*...*/ };
    … …  
    462443\end{lstlisting}
    463444
    464 Regardless of the option chosen for wait semantics, signal must be symmetrical. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) that call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
     445Regardless of the option chosen for wait semantics, signal must be symmetrical. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) than the call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
    465446
    466447Finally, an additionnal semantic which can be very usefull is the \code{signalBlock} routine. This routine behaves like signal for all of the semantics discussed above, but with the subtelty that mutual exclusion is transferred to the waiting task immediately rather than wating for the end of the critical section.
    467 \\
    468448
    469449\subsection{External scheduling} \label{extsched}
    470 As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demonstrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
     450As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demontrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (see \uC) or in terms of data (see Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the reset of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling which is loose object definitions and multi-monitor routines. The following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
    471451
    472452\begin{center}
    … …  
    478458                condition c;
    479459        public:
    480                 void f() { signal(c)}
    481                 void g() { wait(c); }
     460                void f();
     461                void g() { signal}
     462                void h() { wait(c); }
    482463        private:
    483464        }
    … …  
    487468        public:
    488469                void f();
    489                 void g() { _Accept(f); }
     470                void g();
     471                void h() { _Accept(g); }
    490472        private:
    491473        }
    … …  
    495477
    496478In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} was the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
    497 \\
    498479
    499480\subsubsection{Loose object definitions}
    500 In \uC, monitor declarations include an exhaustive list of monitor operations. Since \CFA is not object oriented it becomes both more difficult to implement but also less clear for the user :
     481In \uC monitor definitions include an exhaustive list of monitor operations. Since \CFA is not an object oriented it becomes much more difficult to implement but also much less clear for the user :
    501482
    502483\begin{lstlisting}
    … …  
    504485
    505486        void f(A & mutex a);
    506         void g(A & mutex a) { accept(f); }
    507 \end{lstlisting}
    508 
    509 However, external scheduling is an example where implementation constraints become visible from the interface. Indeed, ince there is no hard limit to the number of threads trying to acquire a monitor concurrently, performance is a significant concern. Here is the pseudo code for the entering phase of a monitor :
     487        void g(A & mutex a);
     488        void h(A & mutex a) { accept(g); }
     489\end{lstlisting}
     490
     491While this is the direct translation of the \uC code, at the time of compiling routine \code{f} the \CFA does not already have a declaration of \code{g} while the \uC compiler does. This means that either the compiler has to dynamically find which routines are "acceptable" or the language needs a way of statically listing "acceptable" routines. Since \CFA has no existing concept that resemble dynamic routine definitions or pattern matching, the static approach seems the more consistent with the current language paradigms. This approach leads to the \uC example being translated to :
     492\begin{lstlisting}
     493        accept( void g(mutex struct A & mutex a) )
     494        mutex struct A {};
     495
     496        void f(A & mutex a) { accept(g); }
     497        void g(A & mutex a);
     498\end{lstlisting}
     499
     500This syntax is the most consistent with the language since it somewhat mimics the \code{forall} declarations. However, the fact that it comes before the struct declaration does means the type needs to be forward declared (done inline in the example). Here are a few alternatives to this syntax : \\
     501\begin{tabular}[t]{l l}
     502Alternative 1 & Alternative 2 \\
     503\begin{lstlisting}
     504mutex struct A
     505accept( void g(A & mutex a) )
     506{};
     507\end{lstlisting} &\begin{lstlisting}
     508mutex struct A {}
     509accept( void g(A & mutex a) );
     510
     511\end{lstlisting} \\
     512Alternative 3 & Alternative 4 \\
     513\begin{lstlisting}
     514mutex struct A {
     515        accept( void g(A & mutex a) )
     516};
     517
     518\end{lstlisting} &\begin{lstlisting}
     519mutex struct A {
     520        accept :
     521                void g(A & mutex a) );
     522};
     523\end{lstlisting}
     524\end{tabular}
     525
     526
     527An other aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine should be scheduled regardless of the overload used. However, this could easily be extended in the future.
     528
     529\subsubsection{Multi-monitor scheduling}
     530
     531External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established :
     532\begin{lstlisting}
     533        accept( void f(mutex struct A & mutex this))
     534        mutex struct A {};
     535
     536        mutex struct B {};
     537
     538        void g(A & mutex a, B & mutex b) {
     539                accept(f); //ambiguous, which monitor
     540        }
     541\end{lstlisting}
     542
     543The obvious solution is to specify the correct monitor as follows :
     544
     545\begin{lstlisting}
     546        accept( void f(mutex struct A & mutex this))
     547        mutex struct A {};
     548
     549        mutex struct B {};
     550
     551        void g(A & mutex a, B & mutex b) {
     552                accept( f, b );
     553        }
     554\end{lstlisting}
     555
     556This is unambiguous. The both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{a} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{b}). This behavior can be extended to multi-monitor accept statment as follows.
     557
     558\begin{lstlisting}
     559        accept( void f(mutex struct A & mutex, mutex struct A & mutex))
     560        mutex struct A {};
     561
     562        mutex struct B {};
     563
     564        void g(A & mutex a, B & mutex b) {
     565                accept( f, b, a );
     566        }
     567\end{lstlisting}
     568
     569Note that the set of monitors passed to the \code{accept} statement must be entirely contained in the set of monitor already acquired in the routine. \code{accept} used in any other context is Undefined Behaviour.
     570
     571\subsection{Implementation Details}
     572\textbf{\large{Work in progress...}}
     573\subsubsection{Interaction with polymorphism}
     574At first glance, interaction between monitors and \CFA's concept of polymorphism seem complexe to support. However, it can be reasoned that entry-point locking can solve most of the issues that could be present with polymorphism.
     575
     576First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore the main question is how to support \code{dtype} polymorphism. We must remember that monitors' main purpose is to ensure mutual exclusion when accessing shared data. This implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handle incomplete types (by definition) no \code{dtype} polymorphic routine can access shared data since the data would require knowledge about the type. Therefore the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. With callsite-locking, this would require significant amount of work since any \code{dtype} routine could have to obtain some lock before calling a routine. However, with entry-point-locking calling a monitor routine becomes exactly the same as calling it from anywhere else.
     577
     578\subsubsection{External scheduling queues}
     579To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they most be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects gut that is a reasonnable contraint. This algorithm choice has two consequences, the ofthe highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probably that half the multi-monitor queues will go unused for the entire duration of the program.
     580
     581\subsection{Other concurrency tools}
     582
     583\section{Parallelism}
     584Historically, computer performance was about processor speeds and instructions count. However, with heat dissipaction being an ever growing challenge, parallelism has become the new source of greatest performance \cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable create high-performance application without caring about parallelism. Indeed, parallelism an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach parallelism is to use \glspl{kthread}. However since these have significant costs and limitations, \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues which all have strengths and weaknesses.
     585
     586\subsection{User-level threads}
     587A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This is the most powerfull solution as it allows all the features of multi-threading while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading complexities are hidden, users still have to think about data races, deadlocks and synchronization issues. This can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
     588
     589Examples of languages that support are Java\cite{Java}, Haskell\cite{Haskell} and \uC\cite{uC++book}.
     590
     591\subsection{Jobs and thread pools}
     592The opposite approach is to base parallelism on \glspl{job}. Indeed, \glspl{job} offer limited flexibility but at the benefit of a simpler user interface. In \gls{job} based systems users express parallelism as units of work and the dependency graph (either explicit or implicit) that tie them together. This means users need not to worry about concurrency but significantly limits the interaction that can occur between different jobs. Indeed, any \gls{job} that blocks also blocks the underlying \gls{kthread}, this effectively mean the CPU utilization, and therefore throughput, will suffer noticeably. The golden standard of this implementation is Intel's TBB library\cite{TBB}.
     593
     594\subsection{Fibers : user-level threads without preemption}
     595Finally, in the middle of the flexibility versus complexity spectrum lay \glspl{fiber} which offer \glspl{uthread} without the complexity of preemption. This means users don't have to worry about other \glspl{fiber} suddenly executing between two instructions which signficantly reduces complexity. However, any call to IO or other concurrency primitives can lead to context switches. Furthermore, users can also block \glspl{fiber} in the middle of their execution without blocking a full processor core. This means users still have to worry about mutual exclusion, deadlocks and race conditions in their code, raising the complexity significantly.
     596\cite{Go}
     597
     598\subsection{Paradigm performance}
     599While the choice between the three paradigms listed above can have significant performance implication, it is difficult to pin the performance implications of chosing a model at the language level. Indeed, in many situations own of these paradigms will show better performance but it all depends on the usage.
     600Having mostly indepent units of work to execute almost guarantess that the \gls{job} based system will have the best performance. However, add interactions between jobs and the processor utilisation might suffer. User-level threads may allow maximum ressource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum.
     601
     602\section{Parallelism in \CFA}
     603As a system level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency.
     604
     605\subsection{Kernel core}\label{kernel}
     606At the ro
     607\subsubsection{Threads}
     608\CFA threads have all the caracteristiques of
     609
     610\subsection{High-level options}\label{tasks}
     611
     612\subsubsection{Thread interface}
     613constructors destructors
     614        initializer lists
     615monitors
     616
     617\subsubsection{Futures}
     618
     619\subsubsection{Implicit threading}
     620Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level.
    510621
    511622\begin{center}
    512 \begin{tabular}{l}
    513 \begin{lstlisting}[language=Pseudo]
    514         if monitor is free :
    515                 enter
    516         elif monitor accepts me :
    517                 enter
    518         else :
    519                 block
     623\begin{tabular}[t]{|c|c|c|}
     624Sequential & System Parallel & Language Parallel \\
     625\begin{lstlisting}
     626void big_sum(int* a, int* b,
     627                 int* out,
     628                 size_t length)
     629{
     630        for(int i = 0; i < length; ++i ) {
     631                out[i] = a[i] + b[i];
     632        }
     633}
     634
     635
     636
     637
     638
     639int* a[10000];
     640int* b[10000];
     641int* c[10000];
     642//... fill in a and b ...
     643big_sum(a, b, c, 10000);
     644\end{lstlisting} &\begin{lstlisting}
     645void big_sum(int* a, int* b,
     646                 int* out,
     647                 size_t length)
     648{
     649        range ar(a, a + length);
     650        range br(b, b + length);
     651        range or(out, out + length);
     652        parfor( ai, bi, oi,
     653        [](int* ai, int* bi, int* oi) {
     654                oi = ai + bi;
     655        });
     656}
     657
     658int* a[10000];
     659int* b[10000];
     660int* c[10000];
     661//... fill in a and b ...
     662big_sum(a, b, c, 10000);
     663\end{lstlisting}&\begin{lstlisting}
     664void big_sum(int* a, int* b,
     665                 int* out,
     666                 size_t length)
     667{
     668        for (ai, bi, oi) in (a, b, out) {
     669                oi = ai + bi;
     670        }
     671}
     672
     673
     674
     675
     676
     677int* a[10000];
     678int* b[10000];
     679int* c[10000];
     680//... fill in a and b ...
     681big_sum(a, b, c, 10000);
    520682\end{lstlisting}
    521683\end{tabular}
    522684\end{center}
    523685
    524 For the \pseudo{monitor is free} condition it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pseudo{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure :
    525 
    526 \begin{center}
    527 {\resizebox{0.4\textwidth}{!}{\input{monitor}}}
    528 \end{center}
    529 
    530 There are other alternatives to these pictures but in the case of this picture implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number of acceptor. However, this relies on the fact that all the acceptable routines are declared with the monitor type. For OO languages this doesn't compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this isn't the case, routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
    531 The alternative would be to have a picture more like this one:
    532 
    533 \begin{center}
    534 {\resizebox{0.4\textwidth}{!}{\input{ext_monitor}}}
    535 \end{center}
    536 
    537 Not storing the queues inside the monitor means that the storage can vary between routines, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to accept to check if a routine is already queued in.
    538 
    539 At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed.
    540 
    541 In either cases here are a few alternatives for the different syntaxes this syntax : \\
    542 \begin{center}
    543 {\renewcommand{\arraystretch}{1.5}
    544 \begin{tabular}[t]{l @{\hskip 0.35in} l}
    545 \hline
    546 \multicolumn{2}{ c }{\code{accept} on type}\\
    547 \hline
    548 Alternative 1 & Alternative 2 \\
    549 \begin{lstlisting}
    550 mutex struct A
    551 accept( void f(A & mutex a) )
    552 {};
    553 \end{lstlisting} &\begin{lstlisting}
    554 mutex struct A {}
    555 accept( void f(A & mutex a) );
    556 
    557 \end{lstlisting} \\
    558 Alternative 3 & Alternative 4 \\
    559 \begin{lstlisting}
    560 mutex struct A {
    561         accept( void f(A & mutex a) )
    562 };
    563 
    564 \end{lstlisting} &\begin{lstlisting}
    565 mutex struct A {
    566         accept :
    567                 void f(A & mutex a) );
    568 };
    569 \end{lstlisting}\\
    570 \hline
    571 \multicolumn{2}{ c }{\code{accept} on routine}\\
    572 \hline
    573 \begin{lstlisting}
    574 mutex struct A {};
    575 
    576 void f(A & mutex a)
    577 
    578 accept( void f(A & mutex a) )
    579 void g(A & mutex a) {
    580         /*...*/
    581 }
    582 \end{lstlisting}&\\
    583 \end{tabular}
    584 }
    585 \end{center}
    586 
    587 An other aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine should be scheduled regardless of the overload used. However, this could easily be extended in the future.
    588 
    589 \subsubsection{Multi-monitor scheduling}
    590 
    591 External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established :
    592 \begin{lstlisting}
    593         accept( void f(mutex struct A & mutex this))
    594         mutex struct A {};
    595 
    596         mutex struct B {};
    597 
    598         void g(A & mutex a, B & mutex b) {
    599                 accept(f); //ambiguous, which monitor
    600         }
    601 \end{lstlisting}
    602 
    603 The obvious solution is to specify the correct monitor as follows :
    604 
    605 \begin{lstlisting}
    606         accept( void f(mutex struct A & mutex this))
    607         mutex struct A {};
    608 
    609         mutex struct B {};
    610 
    611         void g(A & mutex a, B & mutex b) {
    612                 accept( f, b );
    613         }
    614 \end{lstlisting}
    615 
    616 This is unambiguous. Both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{a} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{b}). This behavior can be extended to multi-monitor accept statment as follows.
    617 
    618 \begin{lstlisting}
    619         accept( void f(mutex struct A & mutex, mutex struct A & mutex))
    620         mutex struct A {};
    621 
    622         mutex struct B {};
    623 
    624         void g(A & mutex a, B & mutex b) {
    625                 accept( f, b, a );
    626         }
    627 \end{lstlisting}
    628 
    629 Note that the set of monitors passed to the \code{accept} statement must be entirely contained in the set of monitor already acquired in the routine. \code{accept} used in any other context is Undefined Behaviour.
    630 
    631 \subsubsection{Implementation Details: External scheduling queues}
    632 To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonnable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program.
    633 
    634 \subsection{Other concurrency tools}
    635 TO BE CONTINUED...
    636 
    637 \newpage
    638 \section{Parallelism}
    639 Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being an ever growing challenge, parallelism has become the new source of greatest performance \cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach of parallelism is to use \glspl{kthread}. However since these have significant costs and limitations \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues which all have strengths and weaknesses.
    640 
    641 \subsection{User-level threads}
    642 A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This is the most powerfull solution as it allows all the features of multi-threading while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading complexities are hidden, users still have to think about data races, deadlocks and synchronization issues. This can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
    643 
    644 Examples of languages that support are Java\cite{Java}, Haskell\cite{Haskell} and \uC\cite{uC++book}.
    645 
    646 \subsection{Jobs and thread pools}
    647 The approach on the opposite end of the spectrum is to base parallelism on \glspl{job}. Indeed, \glspl{job} offer limited flexibility but at the benefit of a simpler user interface. In \gls{job} based systems users express parallelism as units of work and the dependency graph (either explicit or implicit) that tie them together. This means users need not to worry about concurrency but significantly limits the interaction that can occur between different jobs. Indeed, any \gls{job} that blocks also blocks the underlying \gls{kthread}, this effectively mean the CPU utilization, and therefore throughput, will suffer noticeably.
    648 The golden standard of this implementation is Intel's TBB library\cite{TBB}.
    649 
    650 \subsection{Fibers : user-level threads without preemption}
    651 Finally, in the middle of the flexibility versus complexity spectrum lay \glspl{fiber} which offer \glspl{uthread} without the complexity of preemption. This means users don't have to worry about other \glspl{fiber} suddenly executing between two instructions which signficantly reduces complexity. However, any call to IO or other concurrency primitives can lead to context switches. Furthermore, users can also block \glspl{fiber} in the middle of their execution without blocking a full processor core. This means users still have to worry about mutual exclusion, deadlocks and race conditions in their code, raising the complexity significantly.
    652 An example of a language that uses fibers is Go\cite{Go}
    653 
    654 \subsection{Paradigm performance}
    655 While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pin the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms will show better performance but it all strongly depends on the usage. Having mostly indepent units of work to execute almost guarantess that the \gls{job} based system will have the best performance. However, add interactions between jobs and the processor utilisation might suffer. User-level threads may allow maximum ressource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum. Furthermore, if the units of uninterrupted work are large enough the paradigm choice will be largely amorticised by the actual work done.
    656 
    657 \section{\CFA 's Thread Building Blocks}
    658 As a system level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. With this said, it is possible to deconstruct the three paradigms details aboved in order to get simple building blocks. Here is a table showing the core caracteristics of the mentionned paradigms :
    659 \begin{center}
    660 \begin{tabular}[t]{| r | c | c |}
    661 \cline{2-3}
    662 \multicolumn{1}{ c| }{} & Has a stack & Preemptive \\
    663 \hline
    664 \Glspl{job} & X & X \\
    665 \hline
    666 \Glspl{fiber} & \checkmark & X \\
    667 \hline
    668 \Glspl{uthread} & \checkmark & \checkmark \\
    669 \hline
    670 \end{tabular}
    671 \end{center}
    672 
    673 As shown in section \ref{cfaparadigms} these different blocks being available in \CFA it is trivial to reproduce any of these paradigm.
    674 
    675 \subsection{Thread Interface}
    676 The basic building blocks of \CFA are \glspl{cfathread}. By default these are implemented as \glspl{uthread} and as such offer a flexible and lightweight threading interface (lightweight comparatievely to \glspl{kthread}). A thread can be declared using a struct declaration prefix with the \code{thread} as follows :
    677 
    678 \begin{lstlisting}
    679         thread struct foo {};
    680 \end{lstlisting}
    681 
    682 Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use some function pointer representation as the interface of threads (for example : \Csharp \cite{Csharp} and Scala \cite{Scala}). However, we consider that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is definetely a special routine in \CFA, we can reuse the existing syntax for declaring routines with unordinary name, i.e. operator overloading. As such the \code{main} routine of a thread can be defined as such :
    683 \begin{lstlisting}
    684         thread struct foo {};
    685 
    686         void ?main(thread foo* this) {
    687                 /*... Some useful code ...*/
    688         }
    689 \end{lstlisting}
    690 
    691 With these semantics it is trivial to write a thread type that takes a function pointer as parameter and executes it on its stack asynchronously :
    692 \begin{lstlisting}
    693         typedef void (*voidFunc)(void);
    694 
    695         thread struct FuncRunner {
    696                 voidFunc func;
    697         };
    698 
    699         //ctor
    700         void ?{}(thread FuncRunner* this, voidFunc inFunc) {
    701                 func = inFunc;
    702         }
    703 
    704         //main
    705         void ?main(thread FuncRunner* this) {
    706                 this->func();
    707         }
    708 \end{lstlisting}
    709 
    710 % In this example \code{func} is a function pointer stored in \acrfull{tls}, which is \CFA is both easy to use and completly typesafe.
    711 
    712 Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is not needed. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} once the constructor has completed and \code{join} before the destructor runs.
    713 \begin{lstlisting}
    714 thread struct FuncRunner; //FuncRunner declared above
    715 
    716 void world() {
    717         sout | "World!" | endl;
    718 }
    719 
    720 void main() {
    721         FuncRunner run = {world};
    722         //Thread run forks here
    723 
    724         //Print to "Hello " and "World!" will be run concurrently
    725         sout | "Hello " | endl;
    726 
    727         //Implicit join at end of scope
    728 }
    729 \end{lstlisting}
    730 This semantic has several advantages over explicit semantics : typesafety is guaranteed, any thread will always be started and stopped exaclty once and users can't make any progamming errors. Furthermore it naturally follows the memory allocation semantics which means users don't need to learn multiple semantics.
    731 
    732 These semantics also naturally scale to multiple threads meaning basic synchronisation is very simple :
    733 \begin{lstlisting}
    734         thread struct MyThread {
    735                 //...
    736         };
    737 
    738         //ctor
    739         void ?{}(thread MyThread* this) {}
    740 
    741         //main
    742         void ?main(thread MyThread* this) {
    743                 //...
    744         }
    745 
    746         void foo() {
    747                 MyThread thrds[10];
    748                 //Start 10 threads at the beginning of the scope
    749 
    750                 DoStuff();
    751 
    752                 //Wait for the 10 threads to finish
    753         }
    754 \end{lstlisting}
    755 
    756 \newpage
    757 \large{\textbf{WORK IN PROGRESS}}
    758 \subsection{The \CFA Kernel : Processors, Clusters and Threads}\label{kernel}
    759 
    760 
    761 \subsection{Paradigms}\label{cfaparadigms}
    762 Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application.
    763 
    764 % \subsection{High-level options}\label{tasks}
    765 %
    766 % \subsubsection{Thread interface}
    767 % constructors destructors
    768 %       initializer lists
    769 % monitors
    770 %
    771 % \subsubsection{Futures}
    772 %
    773 % \subsubsection{Implicit threading}
    774 % Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level.
    775 %
    776 % \begin{center}
    777 % \begin{tabular}[t]{|c|c|c|}
    778 % Sequential & System Parallel & Language Parallel \\
    779 % \begin{lstlisting}
    780 % void big_sum(int* a, int* b,
    781 %                int* out,
    782 %                size_t length)
    783 % {
    784 %       for(int i = 0; i < length; ++i ) {
    785 %               out[i] = a[i] + b[i];
    786 %       }
    787 % }
    788 %
    789 %
    790 %
    791 %
    792 %
    793 % int* a[10000];
    794 % int* b[10000];
    795 % int* c[10000];
    796 % //... fill in a and b ...
    797 % big_sum(a, b, c, 10000);
    798 % \end{lstlisting} &\begin{lstlisting}
    799 % void big_sum(int* a, int* b,
    800 %                int* out,
    801 %                size_t length)
    802 % {
    803 %       range ar(a, a + length);
    804 %       range br(b, b + length);
    805 %       range or(out, out + length);
    806 %       parfor( ai, bi, oi,
    807 %       [](int* ai, int* bi, int* oi) {
    808 %               oi = ai + bi;
    809 %       });
    810 % }
    811 %
    812 % int* a[10000];
    813 % int* b[10000];
    814 % int* c[10000];
    815 % //... fill in a and b ...
    816 % big_sum(a, b, c, 10000);
    817 % \end{lstlisting}&\begin{lstlisting}
    818 % void big_sum(int* a, int* b,
    819 %                int* out,
    820 %                size_t length)
    821 % {
    822 %       for (ai, bi, oi) in (a, b, out) {
    823 %               oi = ai + bi;
    824 %       }
    825 % }
    826 %
    827 %
    828 %
    829 %
    830 %
    831 % int* a[10000];
    832 % int* b[10000];
    833 % int* c[10000];
    834 % //... fill in a and b ...
    835 % big_sum(a, b, c, 10000);
    836 % \end{lstlisting}
    837 % \end{tabular}
    838 % \end{center}
    839 %
    840 % \subsection{Machine setup}\label{machine}
    841 % Threads are all good and well but wee still some OS support to fully utilize available hardware.
    842 %
    843 % \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads?
    844 
    845 \section{Putting it all together}
     686\subsection{Machine setup}\label{machine}
     687Threads are all good and well but wee still some OS support to fully utilize available hardware.
     688
     689\textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads?
    846690
    847691\section{Future work}
    … …  
    852696
    853697\clearpage
    854 \printglossary[type=\acronymtype]
    855698\printglossary
    856699

  • doc/proposals/concurrency/glossary.tex

    ra1e67dd rf0121d7  
    3131\textit{Synonyms : Tasks.}
    3232}
    33 
    34 \longnewglossaryentry{cfacluster}
    35 {name={cluster}}
    36 {
    37 TBD...
    38 
    39 \textit{Synonyms : None.}
    40 }
    41 
    42 \longnewglossaryentry{cfacpu}
    43 {name={processor}}
    44 {
    45 TBD...
    46 
    47 \textit{Synonyms : None.}
    48 }
    49 
    50 \longnewglossaryentry{cfathread}
    51 {name={thread}}
    52 {
    53 TBD...
    54 
    55 \textit{Synonyms : None.}
    56 }
    57 
    58 \longnewglossaryentry{preemption}
    59 {name={preemption}}
    60 {
    61 TBD...
    62 
    63 \textit{Synonyms : None.}
    64 }
    65 
    66 \newacronym{tls}{TLS}{Thread Local Storage}
    67 \newacronym{api}{API}{Application Program Interface}
    68 \newacronym{raii}{RAII}{Ressource Acquisition Is Initialization}

  • doc/user/user.tex

    ra1e67dd rf0121d7  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Thu Sep 29 11:50:28 2016
    14 %% Update Count     : 1325
     13%% Last Modified On : Sun Aug 14 08:23:06 2016
     14%% Update Count     : 1323
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    3333\usepackage{textcomp}
    3434\usepackage[latin1]{inputenc}
    35 
    3635\usepackage{fullpage,times,comment}
    3736\usepackage{epic,eepic}
    … …  
    18541853case 1:  case 2:  case 3: ...
    18551854\end{lstlisting}
    1856 still works.
     1855still work.
    18571856Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
     1857<<<<<<< HEAD
     1858Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthru©, \eg:
     1859=======
    18581860Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, e.g.:
     1861>>>>>>> 080615890f586cb9954c252b55cab47f52c25758
    18591862\begin{lstlisting}
    18601863®choose® ( i ) {

  • src/Parser/lex.cc

    ra1e67dd rf0121d7  
    14691469 * Created On       : Sat Sep 22 08:58:10 2001
    14701470 * Last Modified By : Peter A. Buhr
    1471  * Last Modified On : Tue Oct 18 22:19:37 2016
    1472  * Update Count     : 488
     1471 * Last Modified On : Wed Aug 24 13:27:04 2016
     1472 * Update Count     : 487
    14731473 */
    14741474#line 20 "lex.ll"
    … …  
    15171517
    15181518// identifier, GCC: $ in identifier
     1519// quoted identifier
    15191520// attribute identifier, GCC: $ in identifier
    15201521// numeric constants, CFA: '_' in constant
    … …  
    15311532
    15321533
    1533 #line 1534 "Parser/lex.cc"
     1534#line 1535 "Parser/lex.cc"
    15341535
    15351536#define INITIAL 0
    … …  
    17231724        register int yy_act;
    17241725   
    1725 #line 136 "lex.ll"
     1726#line 139 "lex.ll"
    17261727
    17271728                                   /* line directives */
    1728 #line 1729 "Parser/lex.cc"
     1729#line 1730 "Parser/lex.cc"
    17291730
    17301731        if ( !(yy_init) )
    … …  
    18231824/* rule 1 can match eol */
    18241825YY_RULE_SETUP
    1825 #line 138 "lex.ll"
     1826#line 141 "lex.ll"
    18261827{
    18271828        /* " stop highlighting */
    … …  
    18491850/* rule 2 can match eol */
    18501851YY_RULE_SETUP
    1851 #line 160 "lex.ll"
     1852#line 163 "lex.ll"
    18521853;
    18531854        YY_BREAK
    … …  
    18551856case 3:
    18561857YY_RULE_SETUP
    1857 #line 163 "lex.ll"
     1858#line 166 "lex.ll"
    18581859{ BEGIN COMMENT; }
    18591860        YY_BREAK
    … …  
    18611862/* rule 4 can match eol */
    18621863YY_RULE_SETUP
    1863 #line 164 "lex.ll"
     1864#line 167 "lex.ll"
    18641865;
    18651866        YY_BREAK
    18661867case 5:
    18671868YY_RULE_SETUP
    1868 #line 165 "lex.ll"
     1869#line 168 "lex.ll"
    18691870{ BEGIN 0; }
    18701871        YY_BREAK
    … …  
    18731874/* rule 6 can match eol */
    18741875YY_RULE_SETUP
    1875 #line 168 "lex.ll"
     1876#line 171 "lex.ll"
    18761877;
    18771878        YY_BREAK
    … …  
    18791880case 7:
    18801881YY_RULE_SETUP
    1881 #line 171 "lex.ll"
     1882#line 174 "lex.ll"
    18821883{ WHITE_RETURN(' '); }
    18831884        YY_BREAK
    18841885case 8:
    18851886YY_RULE_SETUP
    1886 #line 172 "lex.ll"
     1887#line 175 "lex.ll"
    18871888{ WHITE_RETURN(' '); }
    18881889        YY_BREAK
    … …  
    18901891/* rule 9 can match eol */
    18911892YY_RULE_SETUP
    1892 #line 173 "lex.ll"
     1893#line 176 "lex.ll"
    18931894{ NEWLINE_RETURN(); }
    18941895        YY_BREAK
    … …  
    18961897case 10:
    18971898YY_RULE_SETUP
    1898 #line 176 "lex.ll"
     1899#line 179 "lex.ll"
    18991900{ KEYWORD_RETURN(ALIGNAS); }                    // C11
    19001901        YY_BREAK
    19011902case 11:
    19021903YY_RULE_SETUP
    1903 #line 177 "lex.ll"
     1904#line 180 "lex.ll"
    19041905{ KEYWORD_RETURN(ALIGNOF); }                    // C11
    19051906        YY_BREAK
    19061907case 12:
    19071908YY_RULE_SETUP
    1908 #line 178 "lex.ll"
     1909#line 181 "lex.ll"
    19091910{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
    19101911        YY_BREAK
    19111912case 13:
    19121913YY_RULE_SETUP
    1913 #line 179 "lex.ll"
     1914#line 182 "lex.ll"
    19141915{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
    19151916        YY_BREAK
    19161917case 14:
    19171918YY_RULE_SETUP
    1918 #line 180 "lex.ll"
     1919#line 183 "lex.ll"
    19191920{ KEYWORD_RETURN(ASM); }
    19201921        YY_BREAK
    19211922case 15:
    19221923YY_RULE_SETUP
    1923 #line 181 "lex.ll"
     1924#line 184 "lex.ll"
    19241925{ KEYWORD_RETURN(ASM); }                                // GCC
    19251926        YY_BREAK
    19261927case 16:
    19271928YY_RULE_SETUP
    1928 #line 182 "lex.ll"
     1929#line 185 "lex.ll"
    19291930{ KEYWORD_RETURN(ASM); }                                // GCC
    19301931        YY_BREAK
    19311932case 17:
    19321933YY_RULE_SETUP
    1933 #line 183 "lex.ll"
     1934#line 186 "lex.ll"
    19341935{ KEYWORD_RETURN(AT); }                                 // CFA
    19351936        YY_BREAK
    19361937case 18:
    19371938YY_RULE_SETUP
    1938 #line 184 "lex.ll"
     1939#line 187 "lex.ll"
    19391940{ KEYWORD_RETURN(ATOMIC); }                             // C11
    19401941        YY_BREAK
    19411942case 19:
    19421943YY_RULE_SETUP
    1943 #line 185 "lex.ll"
     1944#line 188 "lex.ll"
    19441945{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    19451946        YY_BREAK
    19461947case 20:
    19471948YY_RULE_SETUP
    1948 #line 186 "lex.ll"
     1949#line 189 "lex.ll"
    19491950{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    19501951        YY_BREAK
    19511952case 21:
    19521953YY_RULE_SETUP
    1953 #line 187 "lex.ll"
     1954#line 190 "lex.ll"
    19541955{ KEYWORD_RETURN(AUTO); }
    19551956        YY_BREAK
    19561957case 22:
    19571958YY_RULE_SETUP
    1958 #line 188 "lex.ll"
     1959#line 191 "lex.ll"
    19591960{ KEYWORD_RETURN(BOOL); }                               // C99
    19601961        YY_BREAK
    19611962case 23:
    19621963YY_RULE_SETUP
    1963 #line 189 "lex.ll"
     1964#line 192 "lex.ll"
    19641965{ KEYWORD_RETURN(BREAK); }
    19651966        YY_BREAK
    19661967case 24:
    19671968YY_RULE_SETUP
    1968 #line 190 "lex.ll"
     1969#line 193 "lex.ll"
    19691970{ KEYWORD_RETURN(CASE); }
    19701971        YY_BREAK
    19711972case 25:
    19721973YY_RULE_SETUP
    1973 #line 191 "lex.ll"
     1974#line 194 "lex.ll"
    19741975{ KEYWORD_RETURN(CATCH); }                              // CFA
    19751976        YY_BREAK
    19761977case 26:
    19771978YY_RULE_SETUP
    1978 #line 192 "lex.ll"
     1979#line 195 "lex.ll"
    19791980{ KEYWORD_RETURN(CATCHRESUME); }                // CFA
    19801981        YY_BREAK
    19811982case 27:
    19821983YY_RULE_SETUP
    1983 #line 193 "lex.ll"
     1984#line 196 "lex.ll"
    19841985{ KEYWORD_RETURN(CHAR); }
    19851986        YY_BREAK
    19861987case 28:
    19871988YY_RULE_SETUP
    1988 #line 194 "lex.ll"
     1989#line 197 "lex.ll"
    19891990{ KEYWORD_RETURN(CHOOSE); }                             // CFA
    19901991        YY_BREAK
    19911992case 29:
    19921993YY_RULE_SETUP
    1993 #line 195 "lex.ll"
     1994#line 198 "lex.ll"
    19941995{ KEYWORD_RETURN(COMPLEX); }                    // C99
    19951996        YY_BREAK
    19961997case 30:
    19971998YY_RULE_SETUP
    1998 #line 196 "lex.ll"
     1999#line 199 "lex.ll"
    19992000{ KEYWORD_RETURN(COMPLEX); }                    // GCC
    20002001        YY_BREAK
    20012002case 31:
    20022003YY_RULE_SETUP
    2003 #line 197 "lex.ll"
     2004#line 200 "lex.ll"
    20042005{ KEYWORD_RETURN(COMPLEX); }                    // GCC
    20052006        YY_BREAK
    20062007case 32:
    20072008YY_RULE_SETUP
    2008 #line 198 "lex.ll"
     2009#line 201 "lex.ll"
    20092010{ KEYWORD_RETURN(CONST); }
    20102011        YY_BREAK
    20112012case 33:
    20122013YY_RULE_SETUP
    2013 #line 199 "lex.ll"
     2014#line 202 "lex.ll"
    20142015{ KEYWORD_RETURN(CONST); }                              // GCC
    20152016        YY_BREAK
    20162017case 34:
    20172018YY_RULE_SETUP
    2018 #line 200 "lex.ll"
     2019#line 203 "lex.ll"
    20192020{ KEYWORD_RETURN(CONST); }                              // GCC
    20202021        YY_BREAK
    20212022case 35:
    20222023YY_RULE_SETUP
    2023 #line 201 "lex.ll"
     2024#line 204 "lex.ll"
    20242025{ KEYWORD_RETURN(CONTINUE); }
    20252026        YY_BREAK
    20262027case 36:
    20272028YY_RULE_SETUP
    2028 #line 202 "lex.ll"
     2029#line 205 "lex.ll"
    20292030{ KEYWORD_RETURN(DEFAULT); }
    20302031        YY_BREAK
    20312032case 37:
    20322033YY_RULE_SETUP
    2033 #line 203 "lex.ll"
     2034#line 206 "lex.ll"
    20342035{ KEYWORD_RETURN(DISABLE); }                    // CFA
    20352036        YY_BREAK
    20362037case 38:
    20372038YY_RULE_SETUP
    2038 #line 204 "lex.ll"
     2039#line 207 "lex.ll"
    20392040{ KEYWORD_RETURN(DO); }
    20402041        YY_BREAK
    20412042case 39:
    20422043YY_RULE_SETUP
    2043 #line 205 "lex.ll"
     2044#line 208 "lex.ll"
    20442045{ KEYWORD_RETURN(DOUBLE); }
    20452046        YY_BREAK
    20462047case 40:
    20472048YY_RULE_SETUP
    2048 #line 206 "lex.ll"
     2049#line 209 "lex.ll"
    20492050{ KEYWORD_RETURN(DTYPE); }                              // CFA
    20502051        YY_BREAK
    20512052case 41:
    20522053YY_RULE_SETUP
    2053 #line 207 "lex.ll"
     2054#line 210 "lex.ll"
    20542055{ KEYWORD_RETURN(ELSE); }
    20552056        YY_BREAK
    20562057case 42:
    20572058YY_RULE_SETUP
    2058 #line 208 "lex.ll"
     2059#line 211 "lex.ll"
    20592060{ KEYWORD_RETURN(ENABLE); }                             // CFA
    20602061        YY_BREAK
    20612062case 43:
    20622063YY_RULE_SETUP
    2063 #line 209 "lex.ll"
     2064#line 212 "lex.ll"
    20642065{ KEYWORD_RETURN(ENUM); }
    20652066        YY_BREAK
    20662067case 44:
    20672068YY_RULE_SETUP
    2068 #line 210 "lex.ll"
     2069#line 213 "lex.ll"
    20692070{ KEYWORD_RETURN(EXTENSION); }                  // GCC
    20702071        YY_BREAK
    20712072case 45:
    20722073YY_RULE_SETUP
    2073 #line 211 "lex.ll"
     2074#line 214 "lex.ll"
    20742075{ KEYWORD_RETURN(EXTERN); }
    20752076        YY_BREAK
    20762077case 46:
    20772078YY_RULE_SETUP
    2078 #line 212 "lex.ll"
     2079#line 215 "lex.ll"
    20792080{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
    20802081        YY_BREAK
    20812082case 47:
    20822083YY_RULE_SETUP
    2083 #line 213 "lex.ll"
     2084#line 216 "lex.ll"
    20842085{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
    20852086        YY_BREAK
    20862087case 48:
    20872088YY_RULE_SETUP
    2088 #line 214 "lex.ll"
     2089#line 217 "lex.ll"
    20892090{ KEYWORD_RETURN(FINALLY); }                    // CFA
    20902091        YY_BREAK
    20912092case 49:
    20922093YY_RULE_SETUP
    2093 #line 215 "lex.ll"
     2094#line 218 "lex.ll"
    20942095{ KEYWORD_RETURN(FLOAT); }
    20952096        YY_BREAK
    20962097case 50:
    20972098YY_RULE_SETUP
    2098 #line 216 "lex.ll"
     2099#line 219 "lex.ll"
    20992100{ KEYWORD_RETURN(FLOAT); }                              // GCC
    21002101        YY_BREAK
    21012102case 51:
    21022103YY_RULE_SETUP
    2103 #line 217 "lex.ll"
     2104#line 220 "lex.ll"
    21042105{ KEYWORD_RETURN(FOR); }
    21052106        YY_BREAK
    21062107case 52:
    21072108YY_RULE_SETUP
    2108 #line 218 "lex.ll"
     2109#line 221 "lex.ll"
    21092110{ KEYWORD_RETURN(FORALL); }                             // CFA
    21102111        YY_BREAK
    21112112case 53:
    21122113YY_RULE_SETUP
    2113 #line 219 "lex.ll"
     2114#line 222 "lex.ll"
    21142115{ KEYWORD_RETURN(FORTRAN); }
    21152116        YY_BREAK
    21162117case 54:
    21172118YY_RULE_SETUP
    2118 #line 220 "lex.ll"
     2119#line 223 "lex.ll"
    21192120{ KEYWORD_RETURN(FTYPE); }                              // CFA
    21202121        YY_BREAK
    21212122case 55:
    21222123YY_RULE_SETUP
    2123 #line 221 "lex.ll"
     2124#line 224 "lex.ll"
    21242125{ KEYWORD_RETURN(GENERIC); }                    // C11
    21252126        YY_BREAK
    21262127case 56:
    21272128YY_RULE_SETUP
    2128 #line 222 "lex.ll"
     2129#line 225 "lex.ll"
    21292130{ KEYWORD_RETURN(GOTO); }
    21302131        YY_BREAK
    21312132case 57:
    21322133YY_RULE_SETUP
    2133 #line 223 "lex.ll"
     2134#line 226 "lex.ll"
    21342135{ KEYWORD_RETURN(IF); }
    21352136        YY_BREAK
    21362137case 58:
    21372138YY_RULE_SETUP
    2138 #line 224 "lex.ll"
     2139#line 227 "lex.ll"
    21392140{ KEYWORD_RETURN(IMAGINARY); }                  // C99
    21402141        YY_BREAK
    21412142case 59:
    21422143YY_RULE_SETUP
    2143 #line 225 "lex.ll"
     2144#line 228 "lex.ll"
    21442145{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
    21452146        YY_BREAK
    21462147case 60:
    21472148YY_RULE_SETUP
    2148 #line 226 "lex.ll"
     2149#line 229 "lex.ll"
    21492150{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
    21502151        YY_BREAK
    21512152case 61:
    21522153YY_RULE_SETUP
    2153 #line 227 "lex.ll"
     2154#line 230 "lex.ll"
    21542155{ KEYWORD_RETURN(INLINE); }                             // C99
    21552156        YY_BREAK
    21562157case 62:
    21572158YY_RULE_SETUP
    2158 #line 228 "lex.ll"
     2159#line 231 "lex.ll"
    21592160{ KEYWORD_RETURN(INLINE); }                             // GCC
    21602161        YY_BREAK
    21612162case 63:
    21622163YY_RULE_SETUP
    2163 #line 229 "lex.ll"
     2164#line 232 "lex.ll"
    21642165{ KEYWORD_RETURN(INLINE); }                             // GCC
    21652166        YY_BREAK
    21662167case 64:
    21672168YY_RULE_SETUP
    2168 #line 230 "lex.ll"
     2169#line 233 "lex.ll"
    21692170{ KEYWORD_RETURN(INT); }
    21702171        YY_BREAK
    21712172case 65:
    21722173YY_RULE_SETUP
    2173 #line 231 "lex.ll"
     2174#line 234 "lex.ll"
    21742175{ KEYWORD_RETURN(INT); }                                // GCC
    21752176        YY_BREAK
    21762177case 66:
    21772178YY_RULE_SETUP
    2178 #line 232 "lex.ll"
     2179#line 235 "lex.ll"
    21792180{ KEYWORD_RETURN(LABEL); }                              // GCC
    21802181        YY_BREAK
    21812182case 67:
    21822183YY_RULE_SETUP
    2183 #line 233 "lex.ll"
     2184#line 236 "lex.ll"
    21842185{ KEYWORD_RETURN(LONG); }
    21852186        YY_BREAK
    21862187case 68:
    21872188YY_RULE_SETUP
    2188 #line 234 "lex.ll"
     2189#line 237 "lex.ll"
    21892190{ KEYWORD_RETURN(LVALUE); }                             // CFA
    21902191        YY_BREAK
    21912192case 69:
    21922193YY_RULE_SETUP
    2193 #line 235 "lex.ll"
     2194#line 238 "lex.ll"
    21942195{ KEYWORD_RETURN(NORETURN); }                   // C11
    21952196        YY_BREAK
    21962197case 70:
    21972198YY_RULE_SETUP
    2198 #line 236 "lex.ll"
     2199#line 239 "lex.ll"
    21992200{ KEYWORD_RETURN(OFFSETOF); }           // GCC
    22002201        YY_BREAK
    22012202case 71:
    22022203YY_RULE_SETUP
    2203 #line 237 "lex.ll"
     2204#line 240 "lex.ll"
    22042205{ KEYWORD_RETURN(OTYPE); }                              // CFA
    22052206        YY_BREAK
    22062207case 72:
    22072208YY_RULE_SETUP
    2208 #line 238 "lex.ll"
     2209#line 241 "lex.ll"
    22092210{ KEYWORD_RETURN(REGISTER); }
    22102211        YY_BREAK
    22112212case 73:
    22122213YY_RULE_SETUP
    2213 #line 239 "lex.ll"
     2214#line 242 "lex.ll"
    22142215{ KEYWORD_RETURN(RESTRICT); }                   // C99
    22152216        YY_BREAK
    22162217case 74:
    22172218YY_RULE_SETUP
    2218 #line 240 "lex.ll"
     2219#line 243 "lex.ll"
    22192220{ KEYWORD_RETURN(RESTRICT); }                   // GCC
    22202221        YY_BREAK
    22212222case 75:
    22222223YY_RULE_SETUP
    2223 #line 241 "lex.ll"
     2224#line 244 "lex.ll"
    22242225{ KEYWORD_RETURN(RESTRICT); }                   // GCC
    22252226        YY_BREAK
    22262227case 76:
    22272228YY_RULE_SETUP
    2228 #line 242 "lex.ll"
     2229#line 245 "lex.ll"
    22292230{ KEYWORD_RETURN(RETURN); }
    22302231        YY_BREAK
    22312232case 77:
    22322233YY_RULE_SETUP
    2233 #line 243 "lex.ll"
     2234#line 246 "lex.ll"
    22342235{ KEYWORD_RETURN(SHORT); }
    22352236        YY_BREAK
    22362237case 78:
    22372238YY_RULE_SETUP
    2238 #line 244 "lex.ll"
     2239#line 247 "lex.ll"
    22392240{ KEYWORD_RETURN(SIGNED); }
    22402241        YY_BREAK
    22412242case 79:
    22422243YY_RULE_SETUP
    2243 #line 245 "lex.ll"
     2244#line 248 "lex.ll"
    22442245{ KEYWORD_RETURN(SIGNED); }                             // GCC
    22452246        YY_BREAK
    22462247case 80:
    22472248YY_RULE_SETUP
    2248 #line 246 "lex.ll"
     2249#line 249 "lex.ll"
    22492250{ KEYWORD_RETURN(SIGNED); }                             // GCC
    22502251        YY_BREAK
    22512252case 81:
    22522253YY_RULE_SETUP
    2253 #line 247 "lex.ll"
     2254#line 250 "lex.ll"
    22542255{ KEYWORD_RETURN(SIZEOF); }
    22552256        YY_BREAK
    22562257case 82:
    22572258YY_RULE_SETUP
    2258 #line 248 "lex.ll"
     2259#line 251 "lex.ll"
    22592260{ KEYWORD_RETURN(STATIC); }
    22602261        YY_BREAK
    22612262case 83:
    22622263YY_RULE_SETUP
    2263 #line 249 "lex.ll"
     2264#line 252 "lex.ll"
    22642265{ KEYWORD_RETURN(STATICASSERT); }               // C11
    22652266        YY_BREAK
    22662267case 84:
    22672268YY_RULE_SETUP
    2268 #line 250 "lex.ll"
     2269#line 253 "lex.ll"
    22692270{ KEYWORD_RETURN(STRUCT); }
    22702271        YY_BREAK
    22712272case 85:
    22722273YY_RULE_SETUP
    2273 #line 251 "lex.ll"
     2274#line 254 "lex.ll"
    22742275{ KEYWORD_RETURN(SWITCH); }
    22752276        YY_BREAK
    22762277case 86:
    22772278YY_RULE_SETUP
    2278 #line 252 "lex.ll"
     2279#line 255 "lex.ll"
    22792280{ KEYWORD_RETURN(THREADLOCAL); }                // C11
    22802281        YY_BREAK
    22812282case 87:
    22822283YY_RULE_SETUP
    2283 #line 253 "lex.ll"
     2284#line 256 "lex.ll"
    22842285{ KEYWORD_RETURN(THROW); }                              // CFA
    22852286        YY_BREAK
    22862287case 88:
    22872288YY_RULE_SETUP
    2288 #line 254 "lex.ll"
     2289#line 257 "lex.ll"
    22892290{ KEYWORD_RETURN(THROWRESUME); }                // CFA
    22902291        YY_BREAK
    22912292case 89:
    22922293YY_RULE_SETUP
    2293 #line 255 "lex.ll"
     2294#line 258 "lex.ll"
    22942295{ KEYWORD_RETURN(TRAIT); }                              // CFA
    22952296        YY_BREAK
    22962297case 90:
    22972298YY_RULE_SETUP
    2298 #line 256 "lex.ll"
     2299#line 259 "lex.ll"
    22992300{ KEYWORD_RETURN(TRY); }                                // CFA
    23002301        YY_BREAK
    23012302case 91:
    23022303YY_RULE_SETUP
    2303 #line 257 "lex.ll"
     2304#line 260 "lex.ll"
    23042305{ KEYWORD_RETURN(TYPEDEF); }
    23052306        YY_BREAK
    23062307case 92:
    23072308YY_RULE_SETUP
    2308 #line 258 "lex.ll"
     2309#line 261 "lex.ll"
    23092310{ KEYWORD_RETURN(TYPEOF); }                             // GCC
    23102311        YY_BREAK
    23112312case 93:
    23122313YY_RULE_SETUP
    2313 #line 259 "lex.ll"
     2314#line 262 "lex.ll"
    23142315{ KEYWORD_RETURN(TYPEOF); }                             // GCC
    23152316        YY_BREAK
    23162317case 94:
    23172318YY_RULE_SETUP
    2318 #line 260 "lex.ll"
     2319#line 263 "lex.ll"
    23192320{ KEYWORD_RETURN(TYPEOF); }                             // GCC
    23202321        YY_BREAK
    23212322case 95:
    23222323YY_RULE_SETUP
    2323 #line 261 "lex.ll"
     2324#line 264 "lex.ll"
    23242325{ KEYWORD_RETURN(UNION); }
    23252326        YY_BREAK
    23262327case 96:
    23272328YY_RULE_SETUP
    2328 #line 262 "lex.ll"
     2329#line 265 "lex.ll"
    23292330{ KEYWORD_RETURN(UNSIGNED); }
    23302331        YY_BREAK
    23312332case 97:
    23322333YY_RULE_SETUP
    2333 #line 263 "lex.ll"
     2334#line 266 "lex.ll"
    23342335{ KEYWORD_RETURN(VALIST); }                     // GCC
    23352336        YY_BREAK
    23362337case 98:
    23372338YY_RULE_SETUP
    2338 #line 264 "lex.ll"
     2339#line 267 "lex.ll"
    23392340{ KEYWORD_RETURN(VOID); }
    23402341        YY_BREAK
    23412342case 99:
    23422343YY_RULE_SETUP
    2343 #line 265 "lex.ll"
     2344#line 268 "lex.ll"
    23442345{ KEYWORD_RETURN(VOLATILE); }
    23452346        YY_BREAK
    23462347case 100:
    23472348YY_RULE_SETUP
    2348 #line 266 "lex.ll"
     2349#line 269 "lex.ll"
    23492350{ KEYWORD_RETURN(VOLATILE); }                   // GCC
    23502351        YY_BREAK
    23512352case 101:
    23522353YY_RULE_SETUP
    2353 #line 267 "lex.ll"
     2354#line 270 "lex.ll"
    23542355{ KEYWORD_RETURN(VOLATILE); }                   // GCC
    23552356        YY_BREAK
    23562357case 102:
    23572358YY_RULE_SETUP
    2358 #line 268 "lex.ll"
     2359#line 271 "lex.ll"
    23592360{ KEYWORD_RETURN(WHILE); }
    23602361        YY_BREAK
    … …  
    23622363case 103:
    23632364YY_RULE_SETUP
    2364 #line 271 "lex.ll"
    2365 { IDENTIFIER_RETURN(); }
    2366         YY_BREAK
    2367 case 104:
    2368 YY_RULE_SETUP
    2369 #line 272 "lex.ll"
    2370 { ATTRIBUTE_RETURN(); }
    2371         YY_BREAK
    2372 case 105:
    2373 YY_RULE_SETUP
    2374 #line 273 "lex.ll"
    2375 { BEGIN BKQUOTE; }
    2376         YY_BREAK
    2377 case 106:
    2378 YY_RULE_SETUP
    23792365#line 274 "lex.ll"
    23802366{ IDENTIFIER_RETURN(); }
    23812367        YY_BREAK
     2368case 104:
     2369YY_RULE_SETUP
     2370#line 275 "lex.ll"
     2371{ ATTRIBUTE_RETURN(); }
     2372        YY_BREAK
     2373case 105:
     2374YY_RULE_SETUP
     2375#line 276 "lex.ll"
     2376{ BEGIN BKQUOTE; }
     2377        YY_BREAK
     2378case 106:
     2379YY_RULE_SETUP
     2380#line 277 "lex.ll"
     2381{ IDENTIFIER_RETURN(); }
     2382        YY_BREAK
    23822383case 107:
    23832384YY_RULE_SETUP
    2384 #line 275 "lex.ll"
     2385#line 278 "lex.ll"
    23852386{ BEGIN 0; }
    23862387        YY_BREAK
    … …  
    23882389case 108:
    23892390YY_RULE_SETUP
    2390 #line 278 "lex.ll"
     2391#line 281 "lex.ll"
    23912392{ NUMERIC_RETURN(ZERO); }                               // CFA
    23922393        YY_BREAK
    23932394case 109:
    23942395YY_RULE_SETUP
    2395 #line 279 "lex.ll"
     2396#line 282 "lex.ll"
    23962397{ NUMERIC_RETURN(ONE); }                                // CFA
    23972398        YY_BREAK
    23982399case 110:
    23992400YY_RULE_SETUP
    2400 #line 280 "lex.ll"
     2401#line 283 "lex.ll"
    24012402{ NUMERIC_RETURN(INTEGERconstant); }
    24022403        YY_BREAK
    24032404case 111:
    24042405YY_RULE_SETUP
    2405 #line 281 "lex.ll"
     2406#line 284 "lex.ll"
    24062407{ NUMERIC_RETURN(INTEGERconstant); }
    24072408        YY_BREAK
    24082409case 112:
    24092410YY_RULE_SETUP
    2410 #line 282 "lex.ll"
     2411#line 285 "lex.ll"
    24112412{ NUMERIC_RETURN(INTEGERconstant); }
    24122413        YY_BREAK
    24132414case 113:
    24142415YY_RULE_SETUP
    2415 #line 283 "lex.ll"
     2416#line 286 "lex.ll"
    24162417{ NUMERIC_RETURN(FLOATINGconstant); }
    24172418        YY_BREAK
    24182419case 114:
    24192420YY_RULE_SETUP
    2420 #line 284 "lex.ll"
     2421#line 287 "lex.ll"
    24212422{ NUMERIC_RETURN(FLOATINGconstant); }
    24222423        YY_BREAK
    … …  
    24242425case 115:
    24252426YY_RULE_SETUP
    2426 #line 287 "lex.ll"
     2427#line 290 "lex.ll"
    24272428{ BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24282429        YY_BREAK
    24292430case 116:
    24302431YY_RULE_SETUP
    2431 #line 288 "lex.ll"
     2432#line 291 "lex.ll"
    24322433{ strtext->append( yytext, yyleng ); }
    24332434        YY_BREAK
    … …  
    24352436/* rule 117 can match eol */
    24362437YY_RULE_SETUP
    2437 #line 289 "lex.ll"
     2438#line 292 "lex.ll"
    24382439{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    24392440        YY_BREAK
    … …  
    24422443case 118:
    24432444YY_RULE_SETUP
    2444 #line 293 "lex.ll"
     2445#line 296 "lex.ll"
    24452446{ BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24462447        YY_BREAK
    24472448case 119:
    24482449YY_RULE_SETUP
    2449 #line 294 "lex.ll"
     2450#line 297 "lex.ll"
    24502451{ strtext->append( yytext, yyleng ); }
    24512452        YY_BREAK
    … …  
    24532454/* rule 120 can match eol */
    24542455YY_RULE_SETUP
    2455 #line 295 "lex.ll"
     2456#line 298 "lex.ll"
    24562457{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    24572458        YY_BREAK
    … …  
    24602461case 121:
    24612462YY_RULE_SETUP
    2462 #line 299 "lex.ll"
     2463#line 302 "lex.ll"
    24632464{ rm_underscore(); strtext->append( yytext, yyleng ); }
    24642465        YY_BREAK
    … …  
    24662467/* rule 122 can match eol */
    24672468YY_RULE_SETUP
    2468 #line 300 "lex.ll"
     2469#line 303 "lex.ll"
    24692470{}                                              // continuation (ALSO HANDLED BY CPP)
    24702471        YY_BREAK
    24712472case 123:
    24722473YY_RULE_SETUP
    2473 #line 301 "lex.ll"
     2474#line 304 "lex.ll"
    24742475{ strtext->append( yytext, yyleng ); } // unknown escape character
    24752476        YY_BREAK
    … …  
    24772478case 124:
    24782479YY_RULE_SETUP
    2479 #line 304 "lex.ll"
    2480 { ASCIIOP_RETURN(); }
    2481         YY_BREAK
    2482 case 125:
    2483 YY_RULE_SETUP
    2484 #line 305 "lex.ll"
    2485 { ASCIIOP_RETURN(); }
    2486         YY_BREAK
    2487 case 126:
    2488 YY_RULE_SETUP
    2489 #line 306 "lex.ll"
    2490 { ASCIIOP_RETURN(); }
    2491         YY_BREAK
    2492 case 127:
    2493 YY_RULE_SETUP
    24942480#line 307 "lex.ll"
    24952481{ ASCIIOP_RETURN(); }
    24962482        YY_BREAK
    2497 case 128:
     2483case 125:
    24982484YY_RULE_SETUP
    24992485#line 308 "lex.ll"
    25002486{ ASCIIOP_RETURN(); }
    25012487        YY_BREAK
    2502 case 129:
     2488case 126:
    25032489YY_RULE_SETUP
    25042490#line 309 "lex.ll"
    25052491{ ASCIIOP_RETURN(); }
    25062492        YY_BREAK
    2507 case 130:
     2493case 127:
    25082494YY_RULE_SETUP
    25092495#line 310 "lex.ll"
    2510 { ASCIIOP_RETURN(); }                                   // also operator
    2511         YY_BREAK
    2512 case 131:
     2496{ ASCIIOP_RETURN(); }
     2497        YY_BREAK
     2498case 128:
    25132499YY_RULE_SETUP
    25142500#line 311 "lex.ll"
    25152501{ ASCIIOP_RETURN(); }
    25162502        YY_BREAK
    2517 case 132:
     2503case 129:
    25182504YY_RULE_SETUP
    25192505#line 312 "lex.ll"
    25202506{ ASCIIOP_RETURN(); }
    25212507        YY_BREAK
    2522 case 133:
     2508case 130:
    25232509YY_RULE_SETUP
    25242510#line 313 "lex.ll"
    25252511{ ASCIIOP_RETURN(); }                                   // also operator
    25262512        YY_BREAK
     2513case 131:
     2514YY_RULE_SETUP
     2515#line 314 "lex.ll"
     2516{ ASCIIOP_RETURN(); }
     2517        YY_BREAK
     2518case 132:
     2519YY_RULE_SETUP
     2520#line 315 "lex.ll"
     2521{ ASCIIOP_RETURN(); }
     2522        YY_BREAK
     2523case 133:
     2524YY_RULE_SETUP
     2525#line 316 "lex.ll"
     2526{ ASCIIOP_RETURN(); }                                   // also operator
     2527        YY_BREAK
    25272528case 134:
    25282529YY_RULE_SETUP
    2529 #line 314 "lex.ll"
     2530#line 317 "lex.ll"
    25302531{ NAMEDOP_RETURN(ELLIPSIS); }
    25312532        YY_BREAK
    … …  
    25332534case 135:
    25342535YY_RULE_SETUP
    2535 #line 317 "lex.ll"
     2536#line 320 "lex.ll"
    25362537{ RETURN_VAL('['); }
    25372538        YY_BREAK
    25382539case 136:
    25392540YY_RULE_SETUP
    2540 #line 318 "lex.ll"
     2541#line 321 "lex.ll"
    25412542{ RETURN_VAL(']'); }
    25422543        YY_BREAK
    25432544case 137:
    25442545YY_RULE_SETUP
    2545 #line 319 "lex.ll"
     2546#line 322 "lex.ll"
    25462547{ RETURN_VAL('{'); }
    25472548        YY_BREAK
    25482549case 138:
    25492550YY_RULE_SETUP
    2550 #line 320 "lex.ll"
     2551#line 323 "lex.ll"
    25512552{ RETURN_VAL('}'); }
    25522553        YY_BREAK
    … …  
    25542555case 139:
    25552556YY_RULE_SETUP
    2556 #line 323 "lex.ll"
    2557 { ASCIIOP_RETURN(); }
    2558         YY_BREAK
    2559 case 140:
    2560 YY_RULE_SETUP
    2561 #line 324 "lex.ll"
    2562 { ASCIIOP_RETURN(); }
    2563         YY_BREAK
    2564 case 141:
    2565 YY_RULE_SETUP
    2566 #line 325 "lex.ll"
    2567 { ASCIIOP_RETURN(); }
    2568         YY_BREAK
    2569 case 142:
    2570 YY_RULE_SETUP
    25712557#line 326 "lex.ll"
    25722558{ ASCIIOP_RETURN(); }
    25732559        YY_BREAK
    2574 case 143:
     2560case 140:
    25752561YY_RULE_SETUP
    25762562#line 327 "lex.ll"
    25772563{ ASCIIOP_RETURN(); }
    25782564        YY_BREAK
    2579 case 144:
     2565case 141:
    25802566YY_RULE_SETUP
    25812567#line 328 "lex.ll"
    25822568{ ASCIIOP_RETURN(); }
    25832569        YY_BREAK
    2584 case 145:
     2570case 142:
    25852571YY_RULE_SETUP
    25862572#line 329 "lex.ll"
    25872573{ ASCIIOP_RETURN(); }
    25882574        YY_BREAK
    2589 case 146:
     2575case 143:
    25902576YY_RULE_SETUP
    25912577#line 330 "lex.ll"
    25922578{ ASCIIOP_RETURN(); }
    25932579        YY_BREAK
    2594 case 147:
     2580case 144:
    25952581YY_RULE_SETUP
    25962582#line 331 "lex.ll"
    25972583{ ASCIIOP_RETURN(); }
    25982584        YY_BREAK
    2599 case 148:
     2585case 145:
    26002586YY_RULE_SETUP
    26012587#line 332 "lex.ll"
    26022588{ ASCIIOP_RETURN(); }
    26032589        YY_BREAK
    2604 case 149:
     2590case 146:
    26052591YY_RULE_SETUP
    26062592#line 333 "lex.ll"
    26072593{ ASCIIOP_RETURN(); }
    26082594        YY_BREAK
    2609 case 150:
     2595case 147:
    26102596YY_RULE_SETUP
    26112597#line 334 "lex.ll"
    26122598{ ASCIIOP_RETURN(); }
    26132599        YY_BREAK
    2614 case 151:
     2600case 148:
    26152601YY_RULE_SETUP
    26162602#line 335 "lex.ll"
    26172603{ ASCIIOP_RETURN(); }
    26182604        YY_BREAK
    2619 case 152:
     2605case 149:
    26202606YY_RULE_SETUP
    26212607#line 336 "lex.ll"
    26222608{ ASCIIOP_RETURN(); }
    26232609        YY_BREAK
     2610case 150:
     2611YY_RULE_SETUP
     2612#line 337 "lex.ll"
     2613{ ASCIIOP_RETURN(); }
     2614        YY_BREAK
     2615case 151:
     2616YY_RULE_SETUP
     2617#line 338 "lex.ll"
     2618{ ASCIIOP_RETURN(); }
     2619        YY_BREAK
     2620case 152:
     2621YY_RULE_SETUP
     2622#line 339 "lex.ll"
     2623{ ASCIIOP_RETURN(); }
     2624        YY_BREAK
    26242625case 153:
    26252626YY_RULE_SETUP
    2626 #line 338 "lex.ll"
     2627#line 341 "lex.ll"
    26272628{ NAMEDOP_RETURN(ICR); }
    26282629        YY_BREAK
    26292630case 154:
    26302631YY_RULE_SETUP
    2631 #line 339 "lex.ll"
     2632#line 342 "lex.ll"
    26322633{ NAMEDOP_RETURN(DECR); }
    26332634        YY_BREAK
    26342635case 155:
    26352636YY_RULE_SETUP
    2636 #line 340 "lex.ll"
     2637#line 343 "lex.ll"
    26372638{ NAMEDOP_RETURN(EQ); }
    26382639        YY_BREAK
    26392640case 156:
    26402641YY_RULE_SETUP
    2641 #line 341 "lex.ll"
     2642#line 344 "lex.ll"
    26422643{ NAMEDOP_RETURN(NE); }
    26432644        YY_BREAK
    26442645case 157:
    26452646YY_RULE_SETUP
    2646 #line 342 "lex.ll"
     2647#line 345 "lex.ll"
    26472648{ NAMEDOP_RETURN(LS); }
    26482649        YY_BREAK
    26492650case 158:
    26502651YY_RULE_SETUP
    2651 #line 343 "lex.ll"
     2652#line 346 "lex.ll"
    26522653{ NAMEDOP_RETURN(RS); }
    26532654        YY_BREAK
    26542655case 159:
    26552656YY_RULE_SETUP
    2656 #line 344 "lex.ll"
     2657#line 347 "lex.ll"
    26572658{ NAMEDOP_RETURN(LE); }
    26582659        YY_BREAK
    26592660case 160:
    26602661YY_RULE_SETUP
    2661 #line 345 "lex.ll"
     2662#line 348 "lex.ll"
    26622663{ NAMEDOP_RETURN(GE); }
    26632664        YY_BREAK
    26642665case 161:
    26652666YY_RULE_SETUP
    2666 #line 346 "lex.ll"
     2667#line 349 "lex.ll"
    26672668{ NAMEDOP_RETURN(ANDAND); }
    26682669        YY_BREAK
    26692670case 162:
    26702671YY_RULE_SETUP
    2671 #line 347 "lex.ll"
     2672#line 350 "lex.ll"
    26722673{ NAMEDOP_RETURN(OROR); }
    26732674        YY_BREAK
    26742675case 163:
    26752676YY_RULE_SETUP
    2676 #line 348 "lex.ll"
     2677#line 351 "lex.ll"
    26772678{ NAMEDOP_RETURN(ARROW); }
    26782679        YY_BREAK
    26792680case 164:
    26802681YY_RULE_SETUP
    2681 #line 349 "lex.ll"
     2682#line 352 "lex.ll"
    26822683{ NAMEDOP_RETURN(PLUSassign); }
    26832684        YY_BREAK
    26842685case 165:
    26852686YY_RULE_SETUP
    2686 #line 350 "lex.ll"
     2687#line 353 "lex.ll"
    26872688{ NAMEDOP_RETURN(MINUSassign); }
    26882689        YY_BREAK
    26892690case 166:
    26902691YY_RULE_SETUP
    2691 #line 351 "lex.ll"
     2692#line 354 "lex.ll"
    26922693{ NAMEDOP_RETURN(MULTassign); }
    26932694        YY_BREAK
    26942695case 167:
    26952696YY_RULE_SETUP
    2696 #line 352 "lex.ll"
     2697#line 355 "lex.ll"
    26972698{ NAMEDOP_RETURN(DIVassign); }
    26982699        YY_BREAK
    26992700case 168:
    27002701YY_RULE_SETUP
    2701 #line 353 "lex.ll"
     2702#line 356 "lex.ll"
    27022703{ NAMEDOP_RETURN(MODassign); }
    27032704        YY_BREAK
    27042705case 169:
    27052706YY_RULE_SETUP
    2706 #line 354 "lex.ll"
     2707#line 357 "lex.ll"
    27072708{ NAMEDOP_RETURN(ANDassign); }
    27082709        YY_BREAK
    27092710case 170:
    27102711YY_RULE_SETUP
    2711 #line 355 "lex.ll"
     2712#line 358 "lex.ll"
    27122713{ NAMEDOP_RETURN(ORassign); }
    27132714        YY_BREAK
    27142715case 171:
    27152716YY_RULE_SETUP
    2716 #line 356 "lex.ll"
     2717#line 359 "lex.ll"
    27172718{ NAMEDOP_RETURN(ERassign); }
    27182719        YY_BREAK
    27192720case 172:
    27202721YY_RULE_SETUP
    2721 #line 357 "lex.ll"
     2722#line 360 "lex.ll"
    27222723{ NAMEDOP_RETURN(LSassign); }
    27232724        YY_BREAK
    27242725case 173:
    27252726YY_RULE_SETUP
    2726 #line 358 "lex.ll"
     2727#line 361 "lex.ll"
    27272728{ NAMEDOP_RETURN(RSassign); }
    27282729        YY_BREAK
    27292730case 174:
    27302731YY_RULE_SETUP
    2731 #line 360 "lex.ll"
     2732#line 363 "lex.ll"
    27322733{ NAMEDOP_RETURN(ATassign); }                   // CFA
    27332734        YY_BREAK
    … …  
    27352736case 175:
    27362737YY_RULE_SETUP
    2737 #line 363 "lex.ll"
     2738#line 366 "lex.ll"
    27382739{ IDENTIFIER_RETURN(); }                                // unary
    27392740        YY_BREAK
    27402741case 176:
    27412742YY_RULE_SETUP
    2742 #line 364 "lex.ll"
     2743#line 367 "lex.ll"
    27432744{ IDENTIFIER_RETURN(); }
    27442745        YY_BREAK
    27452746case 177:
    27462747YY_RULE_SETUP
    2747 #line 365 "lex.ll"
     2748#line 368 "lex.ll"
    27482749{ IDENTIFIER_RETURN(); }
    27492750        YY_BREAK
    27502751case 178:
    27512752YY_RULE_SETUP
    2752 #line 366 "lex.ll"
     2753#line 369 "lex.ll"
    27532754{ IDENTIFIER_RETURN(); }                // binary
    27542755        YY_BREAK
    … …  
    27812782case 179:
    27822783YY_RULE_SETUP
    2783 #line 393 "lex.ll"
     2784#line 396 "lex.ll"
    27842785{
    27852786        // 1 or 2 character unary operator ?
    … …  
    27962797case 180:
    27972798YY_RULE_SETUP
    2798 #line 405 "lex.ll"
     2799#line 408 "lex.ll"
    27992800{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    28002801        YY_BREAK
    28012802case 181:
    28022803YY_RULE_SETUP
    2803 #line 407 "lex.ll"
     2804#line 410 "lex.ll"
    28042805ECHO;
    28052806        YY_BREAK
    2806 #line 2807 "Parser/lex.cc"
     2807#line 2808 "Parser/lex.cc"
    28072808case YY_STATE_EOF(INITIAL):
    28082809case YY_STATE_EOF(COMMENT):
    … …  
    37793780#define YYTABLES_NAME "yytables"
    37803781
    3781 #line 407 "lex.ll"
     3782#line 410 "lex.ll"
    37823783
    37833784

  • src/Parser/lex.ll

    ra1e67dd rf0121d7  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Tue Oct 18 22:19:37 2016
    13  * Update Count     : 488
     12 * Last Modified On : Wed Aug 24 13:27:04 2016
     13 * Update Count     : 487
    1414 */
    1515
    … …  
    7171                                // identifier, GCC: $ in identifier
    7272identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})*
     73
     74                                // quoted identifier
     75quoted_identifier "`"{identifier}"`"
    7376
    7477                                // attribute identifier, GCC: $ in identifier

  • src/Parser/parser.cc

    ra1e67dd rf0121d7  
    10271027     357,   359,   361,   366,   367,   373,   377,   379,   381,   383,
    10281028     385,   387,   389,   391,   393,   402,   403,   409,   410,   414,
    1029      415,   419,   422,   424,   426,   428,   433,   436,   441,   444,
    1030      446,   448,   453,   466,   468,   470,   472,   474,   476,   478,
    1031      480,   482,   484,   486,   493,   494,   500,   501,   502,   503,
    1032      507,   508,   510,   515,   516,   518,   520,   525,   526,   528,
    1033      533,   534,   536,   541,   542,   544,   546,   548,   553,   554,
    1034      556,   561,   562,   567,   568,   573,   574,   579,   580,   585,
    1035      586,   591,   592,   595,   597,   602,   607,   608,   610,   616,
    1036      617,   621,   622,   623,   624,   625,   626,   627,   628,   629,
    1037      630,   631,   632,   638,   640,   642,   644,   649,   650,   655,
    1038      656,   662,   663,   669,   670,   671,   672,   673,   674,   675,
    1039      676,   677,   687,   694,   696,   706,   707,   712,   714,   720,
    1040      722,   726,   727,   732,   737,   740,   742,   744,   754,   756,
    1041      767,   768,   770,   774,   776,   780,   781,   786,   787,   791,
    1042      796,   797,   801,   803,   809,   810,   814,   816,   818,   820,
    1043      826,   827,   831,   833,   838,   840,   842,   847,   849,   854,
    1044      856,   860,   863,   867,   870,   874,   876,   878,   880,   885,
    1045      887,   889,   894,   896,   898,   900,   902,   907,   909,   911,
    1046      913,   918,   930,   931,   936,   938,   943,   947,   949,   951,
    1047      953,   955,   961,   962,   968,   969,   973,   974,   979,   981,
    1048      987,   988,   990,   995,  1000,  1010,  1012,  1016,  1017,  1022,
    1049     1024,  1028,  1029,  1033,  1035,  1039,  1040,  1044,  1045,  1049,
    1050     1050,  1065,  1066,  1067,  1068,  1069,  1073,  1078,  1085,  1095,
    1051     1100,  1105,  1113,  1118,  1123,  1128,  1133,  1141,  1163,  1168,
    1052     1175,  1177,  1184,  1189,  1194,  1205,  1210,  1215,  1220,  1225,
    1053     1234,  1239,  1247,  1248,  1249,  1250,  1256,  1261,  1269,  1270,
    1054     1271,  1272,  1276,  1277,  1278,  1279,  1284,  1285,  1294,  1295,
    1055     1300,  1301,  1306,  1308,  1310,  1312,  1314,  1317,  1316,  1328,
    1056     1329,  1331,  1341,  1342,  1347,  1349,  1351,  1353,  1355,  1358,
    1057     1360,  1363,  1368,  1370,  1372,  1374,  1376,  1378,  1380,  1382,
    1058     1384,  1386,  1388,  1390,  1392,  1398,  1399,  1401,  1403,  1405,
    1059     1410,  1411,  1417,  1418,  1420,  1422,  1427,  1429,  1431,  1433,
    1060     1438,  1439,  1441,  1443,  1448,  1449,  1451,  1456,  1457,  1459,
    1061     1461,  1466,  1468,  1470,  1475,  1476,  1480,  1482,  1488,  1487,
    1062     1491,  1493,  1498,  1500,  1506,  1507,  1512,  1513,  1515,  1516,
    1063     1525,  1526,  1528,  1530,  1535,  1537,  1543,  1544,  1546,  1549,
    1064     1552,  1557,  1558,  1563,  1568,  1572,  1574,  1580,  1579,  1586,
    1065     1588,  1594,  1595,  1603,  1604,  1608,  1609,  1610,  1612,  1614,
    1066     1621,  1622,  1624,  1626,  1631,  1632,  1638,  1639,  1643,  1644,
    1067     1649,  1650,  1651,  1653,  1661,  1662,  1664,  1667,  1669,  1673,
    1068     1674,  1675,  1677,  1679,  1683,  1688,  1696,  1697,  1706,  1708,
    1069     1713,  1714,  1715,  1719,  1720,  1721,  1725,  1726,  1727,  1731,
    1070     1732,  1733,  1738,  1739,  1740,  1741,  1747,  1748,  1750,  1755,
    1071     1756,  1761,  1762,  1763,  1764,  1765,  1780,  1781,  1786,  1787,
    1072     1793,  1795,  1798,  1800,  1802,  1825,  1826,  1828,  1830,  1835,
    1073     1836,  1838,  1843,  1848,  1849,  1855,  1854,  1858,  1862,  1864,
    1074     1866,  1872,  1873,  1878,  1883,  1885,  1890,  1892,  1893,  1895,
    1075     1900,  1902,  1904,  1909,  1911,  1916,  1921,  1929,  1935,  1934,
    1076     1948,  1949,  1954,  1955,  1959,  1964,  1969,  1977,  1982,  1993,
    1077     1994,  1999,  2000,  2006,  2007,  2011,  2012,  2013,  2016,  2015,
    1078     2026,  2035,  2041,  2047,  2056,  2062,  2068,  2074,  2080,  2088,
    1079     2094,  2102,  2108,  2117,  2118,  2119,  2123,  2127,  2129,  2134,
    1080     2135,  2139,  2140,  2145,  2151,  2152,  2155,  2157,  2158,  2162,
    1081     2163,  2164,  2165,  2199,  2201,  2202,  2204,  2209,  2214,  2219,
    1082     2221,  2223,  2228,  2230,  2232,  2234,  2239,  2241,  2250,  2252,
    1083     2253,  2258,  2260,  2262,  2267,  2269,  2271,  2276,  2278,  2280,
    1084     2289,  2290,  2291,  2295,  2297,  2299,  2304,  2306,  2308,  2313,
    1085     2315,  2317,  2332,  2334,  2335,  2337,  2342,  2343,  2348,  2350,
    1086     2352,  2357,  2359,  2361,  2363,  2368,  2370,  2372,  2382,  2384,
    1087     2385,  2387,  2392,  2394,  2396,  2401,  2403,  2405,  2407,  2412,
    1088     2414,  2416,  2447,  2449,  2450,  2452,  2457,  2462,  2470,  2472,
    1089     2474,  2479,  2481,  2486,  2488,  2502,  2503,  2505,  2510,  2512,
    1090     2514,  2516,  2518,  2523,  2524,  2526,  2528,  2533,  2535,  2537,
    1091     2543,  2545,  2547,  2551,  2553,  2555,  2557,  2571,  2572,  2574,
    1092     2579,  2581,  2583,  2585,  2587,  2592,  2593,  2595,  2597,  2602,
    1093     2604,  2606,  2612,  2613,  2615,  2624,  2627,  2629,  2632,  2634,
    1094     2636,  2649,  2650,  2652,  2657,  2659,  2661,  2663,  2665,  2670,
    1095     2671,  2673,  2675,  2680,  2682,  2690,  2691,  2692,  2697,  2698,
    1096     2702,  2704,  2706,  2708,  2710,  2712,  2719,  2721,  2723,  2725,
    1097     2727,  2730,  2732,  2734,  2736,  2738,  2743,  2745,  2747,  2752,
    1098     2778,  2779,  2781,  2785,  2786,  2790,  2792,  2794,  2796,  2798,
    1099     2800,  2807,  2809,  2811,  2813,  2815,  2817,  2822,  2827,  2829,
    1100     2831,  2849,  2851,  2856,  2857
     1029     415,   419,   422,   424,   426,   428,   433,   435,   440,   443,
     1030     445,   447,   452,   465,   467,   469,   471,   473,   475,   477,
     1031     479,   481,   483,   485,   492,   493,   499,   500,   501,   502,
     1032     506,   507,   509,   514,   515,   517,   519,   524,   525,   527,
     1033     532,   533,   535,   540,   541,   543,   545,   547,   552,   553,
     1034     555,   560,   561,   566,   567,   572,   573,   578,   579,   584,
     1035     585,   590,   591,   594,   596,   601,   606,   607,   609,   615,
     1036     616,   620,   621,   622,   623,   624,   625,   626,   627,   628,
     1037     629,   630,   631,   637,   639,   641,   643,   648,   649,   654,
     1038     655,   661,   662,   668,   669,   670,   671,   672,   673,   674,
     1039     675,   676,   686,   693,   695,   705,   706,   711,   713,   719,
     1040     721,   725,   726,   731,   736,   739,   741,   743,   753,   755,
     1041     766,   767,   769,   773,   775,   779,   780,   785,   786,   790,
     1042     795,   796,   800,   802,   808,   809,   813,   815,   817,   819,
     1043     825,   826,   830,   832,   837,   839,   841,   846,   848,   853,
     1044     855,   859,   862,   866,   869,   873,   875,   877,   879,   884,
     1045     886,   888,   893,   895,   897,   899,   901,   906,   908,   910,
     1046     912,   917,   929,   930,   935,   937,   942,   946,   948,   950,
     1047     952,   954,   960,   961,   967,   968,   972,   973,   978,   980,
     1048     986,   987,   989,   994,   999,  1009,  1011,  1015,  1016,  1021,
     1049    1023,  1027,  1028,  1032,  1034,  1038,  1039,  1043,  1044,  1048,
     1050    1049,  1064,  1065,  1066,  1067,  1068,  1072,  1077,  1084,  1094,
     1051    1099,  1104,  1112,  1117,  1122,  1127,  1132,  1140,  1162,  1167,
     1052    1174,  1176,  1183,  1188,  1193,  1204,  1209,  1214,  1219,  1224,
     1053    1233,  1238,  1246,  1247,  1248,  1249,  1255,  1260,  1268,  1269,
     1054    1270,  1271,  1275,  1276,  1277,  1278,  1283,  1284,  1293,  1294,
     1055    1299,  1300,  1305,  1307,  1309,  1311,  1313,  1316,  1315,  1327,
     1056    1328,  1330,  1340,  1341,  1346,  1348,  1350,  1352,  1354,  1357,
     1057    1359,  1362,  1367,  1369,  1371,  1373,  1375,  1377,  1379,  1381,
     1058    1383,  1385,  1387,  1389,  1391,  1397,  1398,  1400,  1402,  1404,
     1059    1409,  1410,  1416,  1417,  1419,  1421,  1426,  1428,  1430,  1432,
     1060    1437,  1438,  1440,  1442,  1447,  1448,  1450,  1455,  1456,  1458,
     1061    1460,  1465,  1467,  1469,  1474,  1475,  1479,  1481,  1487,  1486,
     1062    1490,  1492,  1497,  1499,  1505,  1506,  1511,  1512,  1514,  1515,
     1063    1524,  1525,  1527,  1529,  1534,  1536,  1542,  1543,  1545,  1548,
     1064    1551,  1556,  1557,  1562,  1567,  1571,  1573,  1579,  1578,  1585,
     1065    1587,  1593,  1594,  1602,  1603,  1607,  1608,  1609,  1611,  1613,
     1066    1620,  1621,  1623,  1625,  1630,  1631,  1637,  1638,  1642,  1643,
     1067    1648,  1649,  1650,  1652,  1660,  1661,  1663,  1666,  1668,  1672,
     1068    1673,  1674,  1676,  1678,  1682,  1687,  1695,  1696,  1705,  1707,
     1069    1712,  1713,  1714,  1718,  1719,  1720,  1724,  1725,  1726,  1730,
     1070    1731,  1732,  1737,  1738,  1739,  1740,  1746,  1747,  1749,  1754,
     1071    1755,  1760,  1761,  1762,  1763,  1764,  1779,  1780,  1785,  1786,
     1072    1792,  1794,  1797,  1799,  1801,  1824,  1825,  1827,  1829,  1834,
     1073    1835,  1837,  1842,  1847,  1848,  1854,  1853,  1857,  1861,  1863,
     1074    1865,  1871,  1872,  1877,  1882,  1884,  1889,  1891,  1892,  1894,
     1075    1899,  1901,  1903,  1908,  1910,  1915,  1920,  1928,  1934,  1933,
     1076    1947,  1948,  1953,  1954,  1958,  1963,  1968,  1976,  1981,  1992,
     1077    1993,  1998,  1999,  2005,  2006,  2010,  2011,  2012,  2015,  2014,
     1078    2025,  2034,  2040,  2046,  2055,  2061,  2067,  2073,  2079,  2087,
     1079    2093,  2101,  2107,  2116,  2117,  2118,  2122,  2126,  2128,  2133,
     1080    2134,  2138,  2139,  2144,  2150,  2151,  2154,  2156,  2157,  2161,
     1081    2162,  2163,  2164,  2198,  2200,  2201,  2203,  2208,  2213,  2218,
     1082    2220,  2222,  2227,  2229,  2231,  2233,  2238,  2240,  2249,  2251,
     1083    2252,  2257,  2259,  2261,  2266,  2268,  2270,  2275,  2277,  2279,
     1084    2288,  2289,  2290,  2294,  2296,  2298,  2303,  2305,  2307,  2312,
     1085    2314,  2316,  2331,  2333,  2334,  2336,  2341,  2342,  2347,  2349,
     1086    2351,  2356,  2358,  2360,  2362,  2367,  2369,  2371,  2381,  2383,
     1087    2384,  2386,  2391,  2393,  2395,  2400,  2402,  2404,  2406,  2411,
     1088    2413,  2415,  2446,  2448,  2449,  2451,  2456,  2461,  2469,  2471,
     1089    2473,  2478,  2480,  2485,  2487,  2501,  2502,  2504,  2509,  2511,
     1090    2513,  2515,  2517,  2522,  2523,  2525,  2527,  2532,  2534,  2536,
     1091    2542,  2544,  2546,  2550,  2552,  2554,  2556,  2570,  2571,  2573,
     1092    2578,  2580,  2582,  2584,  2586,  2591,  2592,  2594,  2596,  2601,
     1093    2603,  2605,  2611,  2612,  2614,  2623,  2626,  2628,  2631,  2633,
     1094    2635,  2648,  2649,  2651,  2656,  2658,  2660,  2662,  2664,  2669,
     1095    2670,  2672,  2674,  2679,  2681,  2689,  2690,  2691,  2696,  2697,
     1096    2701,  2703,  2705,  2707,  2709,  2711,  2718,  2720,  2722,  2724,
     1097    2726,  2728,  2730,  2732,  2734,  2736,  2741,  2743,  2745,  2750,
     1098    2776,  2777,  2779,  2783,  2784,  2788,  2790,  2792,  2794,  2796,
     1099    2798,  2805,  2807,  2809,  2811,  2813,  2815,  2820,  2825,  2827,
     1100    2829,  2847,  2849,  2854,  2855
    11011101};
    11021102#endif
    … …  
    52025202
    52035203/* Line 1806 of yacc.c  */
    5204 #line 437 "parser.yy"
     5204#line 436 "parser.yy"
    52055205    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
    52065206    break;
    … …  
    52095209
    52105210/* Line 1806 of yacc.c  */
    5211 #line 445 "parser.yy"
     5211#line 444 "parser.yy"
    52125212    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    52135213    break;
    … …  
    52165216
    52175217/* Line 1806 of yacc.c  */
    5218 #line 447 "parser.yy"
     5218#line 446 "parser.yy"
    52195219    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    52205220    break;
    … …  
    52235223
    52245224/* Line 1806 of yacc.c  */
    5225 #line 449 "parser.yy"
     5225#line 448 "parser.yy"
    52265226    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    52275227    break;
    … …  
    52305230
    52315231/* Line 1806 of yacc.c  */
    5232 #line 454 "parser.yy"
     5232#line 453 "parser.yy"
    52335233    {
    52345234                        switch ( (yyvsp[(1) - (2)].op) ) {
    … …  
    52485248
    52495249/* Line 1806 of yacc.c  */
    5250 #line 467 "parser.yy"
     5250#line 466 "parser.yy"
    52515251    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    52525252    break;
    … …  
    52555255
    52565256/* Line 1806 of yacc.c  */
    5257 #line 469 "parser.yy"
     5257#line 468 "parser.yy"
    52585258    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    52595259    break;
    … …  
    52625262
    52635263/* Line 1806 of yacc.c  */
    5264 #line 471 "parser.yy"
     5264#line 470 "parser.yy"
    52655265    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    52665266    break;
    … …  
    52695269
    52705270/* Line 1806 of yacc.c  */
    5271 #line 473 "parser.yy"
     5271#line 472 "parser.yy"
    52725272    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52735273    break;
    … …  
    52765276
    52775277/* Line 1806 of yacc.c  */
    5278 #line 475 "parser.yy"
     5278#line 474 "parser.yy"
    52795279    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52805280    break;
    … …  
    52835283
    52845284/* Line 1806 of yacc.c  */
    5285 #line 477 "parser.yy"
     5285#line 476 "parser.yy"
    52865286    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52875287    break;
    … …  
    52905290
    52915291/* Line 1806 of yacc.c  */
    5292 #line 479 "parser.yy"
     5292#line 478 "parser.yy"
    52935293    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52945294    break;
    … …  
    52975297
    52985298/* Line 1806 of yacc.c  */
    5299 #line 481 "parser.yy"
     5299#line 480 "parser.yy"
    53005300    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
    53015301    break;
    … …  
    53045304
    53055305/* Line 1806 of yacc.c  */
    5306 #line 483 "parser.yy"
     5306#line 482 "parser.yy"
    53075307    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
    53085308    break;
    … …  
    53115311
    53125312/* Line 1806 of yacc.c  */
    5313 #line 485 "parser.yy"
     5313#line 484 "parser.yy"
    53145314    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    53155315    break;
    … …  
    53185318
    53195319/* Line 1806 of yacc.c  */
    5320 #line 487 "parser.yy"
     5320#line 486 "parser.yy"
    53215321    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
    53225322    break;
    … …  
    53255325
    53265326/* Line 1806 of yacc.c  */
     5327#line 492 "parser.yy"
     5328    { (yyval.op) = OperKinds::PointTo; }
     5329    break;
     5330
     5331  case 65:
     5332
     5333/* Line 1806 of yacc.c  */
    53275334#line 493 "parser.yy"
    5328     { (yyval.op) = OperKinds::PointTo; }
    5329     break;
    5330 
    5331   case 65:
    5332 
    5333 /* Line 1806 of yacc.c  */
    5334 #line 494 "parser.yy"
    53355335    { (yyval.op) = OperKinds::AddressOf; }
    53365336    break;
    … …  
    53395339
    53405340/* Line 1806 of yacc.c  */
     5341#line 499 "parser.yy"
     5342    { (yyval.op) = OperKinds::UnPlus; }
     5343    break;
     5344
     5345  case 67:
     5346
     5347/* Line 1806 of yacc.c  */
    53415348#line 500 "parser.yy"
    5342     { (yyval.op) = OperKinds::UnPlus; }
    5343     break;
    5344 
    5345   case 67:
     5349    { (yyval.op) = OperKinds::UnMinus; }
     5350    break;
     5351
     5352  case 68:
    53465353
    53475354/* Line 1806 of yacc.c  */
    53485355#line 501 "parser.yy"
    5349     { (yyval.op) = OperKinds::UnMinus; }
    5350     break;
    5351 
    5352   case 68:
     5356    { (yyval.op) = OperKinds::Neg; }
     5357    break;
     5358
     5359  case 69:
    53535360
    53545361/* Line 1806 of yacc.c  */
    53555362#line 502 "parser.yy"
    5356     { (yyval.op) = OperKinds::Neg; }
    5357     break;
    5358 
    5359   case 69:
    5360 
    5361 /* Line 1806 of yacc.c  */
    5362 #line 503 "parser.yy"
    53635363    { (yyval.op) = OperKinds::BitNeg; }
    53645364    break;
    … …  
    53675367
    53685368/* Line 1806 of yacc.c  */
    5369 #line 509 "parser.yy"
     5369#line 508 "parser.yy"
    53705370    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    53715371    break;
    … …  
    53745374
    53755375/* Line 1806 of yacc.c  */
    5376 #line 511 "parser.yy"
     5376#line 510 "parser.yy"
    53775377    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    53785378    break;
    … …  
    53815381
    53825382/* Line 1806 of yacc.c  */
    5383 #line 517 "parser.yy"
     5383#line 516 "parser.yy"
    53845384    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53855385    break;
    … …  
    53885388
    53895389/* Line 1806 of yacc.c  */
    5390 #line 519 "parser.yy"
     5390#line 518 "parser.yy"
    53915391    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53925392    break;
    … …  
    53955395
    53965396/* Line 1806 of yacc.c  */
    5397 #line 521 "parser.yy"
     5397#line 520 "parser.yy"
    53985398    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53995399    break;
    … …  
    54025402
    54035403/* Line 1806 of yacc.c  */
    5404 #line 527 "parser.yy"
     5404#line 526 "parser.yy"
    54055405    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54065406    break;
    … …  
    54095409
    54105410/* Line 1806 of yacc.c  */
    5411 #line 529 "parser.yy"
     5411#line 528 "parser.yy"
    54125412    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54135413    break;
    … …  
    54165416
    54175417/* Line 1806 of yacc.c  */
    5418 #line 535 "parser.yy"
     5418#line 534 "parser.yy"
    54195419    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54205420    break;
    … …  
    54235423
    54245424/* Line 1806 of yacc.c  */
    5425 #line 537 "parser.yy"
     5425#line 536 "parser.yy"
    54265426    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54275427    break;
    … …  
    54305430
    54315431/* Line 1806 of yacc.c  */
    5432 #line 543 "parser.yy"
     5432#line 542 "parser.yy"
    54335433    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54345434    break;
    … …  
    54375437
    54385438/* Line 1806 of yacc.c  */
    5439 #line 545 "parser.yy"
     5439#line 544 "parser.yy"
    54405440    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54415441    break;
    … …  
    54445444
    54455445/* Line 1806 of yacc.c  */
    5446 #line 547 "parser.yy"
     5446#line 546 "parser.yy"
    54475447    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54485448    break;
    … …  
    54515451
    54525452/* Line 1806 of yacc.c  */
    5453 #line 549 "parser.yy"
     5453#line 548 "parser.yy"
    54545454    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54555455    break;
    … …  
    54585458
    54595459/* Line 1806 of yacc.c  */
    5460 #line 555 "parser.yy"
     5460#line 554 "parser.yy"
    54615461    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54625462    break;
    … …  
    54655465
    54665466/* Line 1806 of yacc.c  */
    5467 #line 557 "parser.yy"
     5467#line 556 "parser.yy"
    54685468    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54695469    break;
    … …  
    54725472
    54735473/* Line 1806 of yacc.c  */
    5474 #line 563 "parser.yy"
     5474#line 562 "parser.yy"
    54755475    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54765476    break;
    … …  
    54795479
    54805480/* Line 1806 of yacc.c  */
    5481 #line 569 "parser.yy"
     5481#line 568 "parser.yy"
    54825482    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54835483    break;
    … …  
    54865486
    54875487/* Line 1806 of yacc.c  */
    5488 #line 575 "parser.yy"
     5488#line 574 "parser.yy"
    54895489    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54905490    break;
    … …  
    54935493
    54945494/* Line 1806 of yacc.c  */
    5495 #line 581 "parser.yy"
     5495#line 580 "parser.yy"
    54965496    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    54975497    break;
    … …  
    55005500
    55015501/* Line 1806 of yacc.c  */
    5502 #line 587 "parser.yy"
     5502#line 586 "parser.yy"
    55035503    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    55045504    break;
    … …  
    55075507
    55085508/* Line 1806 of yacc.c  */
    5509 #line 593 "parser.yy"
     5509#line 592 "parser.yy"
    55105510    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55115511    break;
    … …  
    55145514
    55155515/* Line 1806 of yacc.c  */
    5516 #line 596 "parser.yy"
     5516#line 595 "parser.yy"
    55175517    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    55185518    break;
    … …  
    55215521
    55225522/* Line 1806 of yacc.c  */
    5523 #line 598 "parser.yy"
     5523#line 597 "parser.yy"
    55245524    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55255525    break;
    … …  
    55285528
    55295529/* Line 1806 of yacc.c  */
    5530 #line 609 "parser.yy"
     5530#line 608 "parser.yy"
    55315531    { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    55325532    break;
    … …  
    55355535
    55365536/* Line 1806 of yacc.c  */
    5537 #line 611 "parser.yy"
     5537#line 610 "parser.yy"
    55385538    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    55395539    break;
    … …  
    55425542
    55435543/* Line 1806 of yacc.c  */
    5544 #line 616 "parser.yy"
     5544#line 615 "parser.yy"
    55455545    { (yyval.en) = nullptr; }
    55465546    break;
    … …  
    55495549
    55505550/* Line 1806 of yacc.c  */
     5551#line 620 "parser.yy"
     5552    { (yyval.op) = OperKinds::Assign; }
     5553    break;
     5554
     5555  case 112:
     5556
     5557/* Line 1806 of yacc.c  */
    55515558#line 621 "parser.yy"
    5552     { (yyval.op) = OperKinds::Assign; }
    5553     break;
    5554 
    5555   case 112:
     5559    { (yyval.op) = OperKinds::AtAssn; }
     5560    break;
     5561
     5562  case 113:
    55565563
    55575564/* Line 1806 of yacc.c  */
    55585565#line 622 "parser.yy"
    5559     { (yyval.op) = OperKinds::AtAssn; }
    5560     break;
    5561 
    5562   case 113:
     5566    { (yyval.op) = OperKinds::MulAssn; }
     5567    break;
     5568
     5569  case 114:
    55635570
    55645571/* Line 1806 of yacc.c  */
    55655572#line 623 "parser.yy"
    5566     { (yyval.op) = OperKinds::MulAssn; }
    5567     break;
    5568 
    5569   case 114:
     5573    { (yyval.op) = OperKinds::DivAssn; }
     5574    break;
     5575
     5576  case 115:
    55705577
    55715578/* Line 1806 of yacc.c  */
    55725579#line 624 "parser.yy"
    5573     { (yyval.op) = OperKinds::DivAssn; }
    5574     break;
    5575 
    5576   case 115:
     5580    { (yyval.op) = OperKinds::ModAssn; }
     5581    break;
     5582
     5583  case 116:
    55775584
    55785585/* Line 1806 of yacc.c  */
    55795586#line 625 "parser.yy"
    5580     { (yyval.op) = OperKinds::ModAssn; }
    5581     break;
    5582 
    5583   case 116:
     5587    { (yyval.op) = OperKinds::PlusAssn; }
     5588    break;
     5589
     5590  case 117:
    55845591
    55855592/* Line 1806 of yacc.c  */
    55865593#line 626 "parser.yy"
    5587     { (yyval.op) = OperKinds::PlusAssn; }
    5588     break;
    5589 
    5590   case 117:
     5594    { (yyval.op) = OperKinds::MinusAssn; }
     5595    break;
     5596
     5597  case 118:
    55915598
    55925599/* Line 1806 of yacc.c  */
    55935600#line 627 "parser.yy"
    5594     { (yyval.op) = OperKinds::MinusAssn; }
    5595     break;
    5596 
    5597   case 118:
     5601    { (yyval.op) = OperKinds::LSAssn; }
     5602    break;
     5603
     5604  case 119:
    55985605
    55995606/* Line 1806 of yacc.c  */
    56005607#line 628 "parser.yy"
    5601     { (yyval.op) = OperKinds::LSAssn; }
    5602     break;
    5603 
    5604   case 119:
     5608    { (yyval.op) = OperKinds::RSAssn; }
     5609    break;
     5610
     5611  case 120:
    56055612
    56065613/* Line 1806 of yacc.c  */
    56075614#line 629 "parser.yy"
    5608     { (yyval.op) = OperKinds::RSAssn; }
    5609     break;
    5610 
    5611   case 120:
     5615    { (yyval.op) = OperKinds::AndAssn; }
     5616    break;
     5617
     5618  case 121:
    56125619
    56135620/* Line 1806 of yacc.c  */
    56145621#line 630 "parser.yy"
    5615     { (yyval.op) = OperKinds::AndAssn; }
    5616     break;
    5617 
    5618   case 121:
     5622    { (yyval.op) = OperKinds::ERAssn; }
     5623    break;
     5624
     5625  case 122:
    56195626
    56205627/* Line 1806 of yacc.c  */
    56215628#line 631 "parser.yy"
    5622     { (yyval.op) = OperKinds::ERAssn; }
    5623     break;
    5624 
    5625   case 122:
    5626 
    5627 /* Line 1806 of yacc.c  */
    5628 #line 632 "parser.yy"
    56295629    { (yyval.op) = OperKinds::OrAssn; }
    56305630    break;
    … …  
    56335633
    56345634/* Line 1806 of yacc.c  */
    5635 #line 639 "parser.yy"
     5635#line 638 "parser.yy"
    56365636    { (yyval.en) = new ExpressionNode( build_tuple() ); }
    56375637    break;
    … …  
    56405640
    56415641/* Line 1806 of yacc.c  */
    5642 #line 641 "parser.yy"
     5642#line 640 "parser.yy"
    56435643    { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    56445644    break;
    … …  
    56475647
    56485648/* Line 1806 of yacc.c  */
    5649 #line 643 "parser.yy"
     5649#line 642 "parser.yy"
    56505650    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
    56515651    break;
    … …  
    56545654
    56555655/* Line 1806 of yacc.c  */
    5656 #line 645 "parser.yy"
     5656#line 644 "parser.yy"
    56575657    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
    56585658    break;
    … …  
    56615661
    56625662/* Line 1806 of yacc.c  */
    5663 #line 651 "parser.yy"
     5663#line 650 "parser.yy"
    56645664    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    56655665    break;
    … …  
    56685668
    56695669/* Line 1806 of yacc.c  */
    5670 #line 657 "parser.yy"
     5670#line 656 "parser.yy"
    56715671    { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56725672    break;
    … …  
    56755675
    56765676/* Line 1806 of yacc.c  */
    5677 #line 662 "parser.yy"
     5677#line 661 "parser.yy"
    56785678    { (yyval.en) = 0; }
    56795679    break;
    … …  
    56825682
    56835683/* Line 1806 of yacc.c  */
    5684 #line 671 "parser.yy"
     5684#line 670 "parser.yy"
    56855685    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56865686    break;
    … …  
    56895689
    56905690/* Line 1806 of yacc.c  */
    5691 #line 678 "parser.yy"
     5691#line 677 "parser.yy"
    56925692    {
    56935693                        Token fn;
    … …  
    57005700
    57015701/* Line 1806 of yacc.c  */
    5702 #line 688 "parser.yy"
     5702#line 687 "parser.yy"
    57035703    {
    57045704                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
    … …  
    57095709
    57105710/* Line 1806 of yacc.c  */
    5711 #line 695 "parser.yy"
     5711#line 694 "parser.yy"
    57125712    { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
    57135713    break;
    … …  
    57165716
    57175717/* Line 1806 of yacc.c  */
    5718 #line 702 "parser.yy"
     5718#line 701 "parser.yy"
    57195719    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
    57205720    break;
    … …  
    57235723
    57245724/* Line 1806 of yacc.c  */
    5725 #line 708 "parser.yy"
     5725#line 707 "parser.yy"
    57265726    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    57275727    break;
    … …  
    57305730
    57315731/* Line 1806 of yacc.c  */
    5732 #line 713 "parser.yy"
     5732#line 712 "parser.yy"
    57335733    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57345734    break;
    … …  
    57375737
    57385738/* Line 1806 of yacc.c  */
    5739 #line 715 "parser.yy"
     5739#line 714 "parser.yy"
    57405740    {   // mark all fields in list
    57415741                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    57485748
    57495749/* Line 1806 of yacc.c  */
    5750 #line 721 "parser.yy"
     5750#line 720 "parser.yy"
    57515751    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57525752    break;
    … …  
    57555755
    57565756/* Line 1806 of yacc.c  */
    5757 #line 728 "parser.yy"
     5757#line 727 "parser.yy"
    57585758    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57595759    break;
    … …  
    57625762
    57635763/* Line 1806 of yacc.c  */
    5764 #line 733 "parser.yy"
     5764#line 732 "parser.yy"
    57655765    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
    57665766    break;
    … …  
    57695769
    57705770/* Line 1806 of yacc.c  */
    5771 #line 739 "parser.yy"
     5771#line 738 "parser.yy"
    57725772    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
    57735773    break;
    … …  
    57765776
    57775777/* Line 1806 of yacc.c  */
    5778 #line 741 "parser.yy"
     5778#line 740 "parser.yy"
    57795779    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
    57805780    break;
    … …  
    57835783
    57845784/* Line 1806 of yacc.c  */
    5785 #line 743 "parser.yy"
     5785#line 742 "parser.yy"
    57865786    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    57875787    break;
    … …  
    57905790
    57915791/* Line 1806 of yacc.c  */
    5792 #line 745 "parser.yy"
     5792#line 744 "parser.yy"
    57935793    {
    57945794                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    … …  
    58055805
    58065806/* Line 1806 of yacc.c  */
    5807 #line 755 "parser.yy"
     5807#line 754 "parser.yy"
    58085808    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    58095809    break;
    … …  
    58125812
    58135813/* Line 1806 of yacc.c  */
    5814 #line 757 "parser.yy"
     5814#line 756 "parser.yy"
    58155815    {
    58165816                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    … …  
    58225822
    58235823/* Line 1806 of yacc.c  */
    5824 #line 767 "parser.yy"
     5824#line 766 "parser.yy"
    58255825    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    58265826    break;
    … …  
    58295829
    58305830/* Line 1806 of yacc.c  */
    5831 #line 769 "parser.yy"
     5831#line 768 "parser.yy"
    58325832    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58335833    break;
    … …  
    58365836
    58375837/* Line 1806 of yacc.c  */
    5838 #line 774 "parser.yy"
     5838#line 773 "parser.yy"
    58395839    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
    58405840    break;
    … …  
    58435843
    58445844/* Line 1806 of yacc.c  */
    5845 #line 776 "parser.yy"
     5845#line 775 "parser.yy"
    58465846    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
    58475847    break;
    … …  
    58505850
    58515851/* Line 1806 of yacc.c  */
     5852#line 779 "parser.yy"
     5853    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     5854    break;
     5855
     5856  case 166:
     5857
     5858/* Line 1806 of yacc.c  */
    58525859#line 780 "parser.yy"
    5853     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    5854     break;
    5855 
    5856   case 166:
    5857 
    5858 /* Line 1806 of yacc.c  */
    5859 #line 781 "parser.yy"
    58605860    { (yyval.sn) = new StatementNode( build_default() ); }
    58615861    break;
    … …  
    58645864
    58655865/* Line 1806 of yacc.c  */
    5866 #line 787 "parser.yy"
     5866#line 786 "parser.yy"
    58675867    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
    58685868    break;
    … …  
    58715871
    58725872/* Line 1806 of yacc.c  */
    5873 #line 791 "parser.yy"
     5873#line 790 "parser.yy"
    58745874    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    58755875    break;
    … …  
    58785878
    58795879/* Line 1806 of yacc.c  */
    5880 #line 796 "parser.yy"
     5880#line 795 "parser.yy"
    58815881    { (yyval.sn) = 0; }
    58825882    break;
    … …  
    58855885
    58865886/* Line 1806 of yacc.c  */
    5887 #line 802 "parser.yy"
     5887#line 801 "parser.yy"
    58885888    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    58895889    break;
    … …  
    58925892
    58935893/* Line 1806 of yacc.c  */
    5894 #line 804 "parser.yy"
     5894#line 803 "parser.yy"
    58955895    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
    58965896    break;
    … …  
    58995899
    59005900/* Line 1806 of yacc.c  */
    5901 #line 809 "parser.yy"
     5901#line 808 "parser.yy"
    59025902    { (yyval.sn) = 0; }
    59035903    break;
    … …  
    59065906
    59075907/* Line 1806 of yacc.c  */
    5908 #line 815 "parser.yy"
     5908#line 814 "parser.yy"
    59095909    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    59105910    break;
    … …  
    59135913
    59145914/* Line 1806 of yacc.c  */
    5915 #line 817 "parser.yy"
     5915#line 816 "parser.yy"
    59165916    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    59175917    break;
    … …  
    59205920
    59215921/* Line 1806 of yacc.c  */
    5922 #line 819 "parser.yy"
     5922#line 818 "parser.yy"
    59235923    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    59245924    break;
    … …  
    59275927
    59285928/* Line 1806 of yacc.c  */
    5929 #line 821 "parser.yy"
     5929#line 820 "parser.yy"
    59305930    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    59315931    break;
    … …  
    59345934
    59355935/* Line 1806 of yacc.c  */
    5936 #line 826 "parser.yy"
     5936#line 825 "parser.yy"
    59375937    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    59385938    break;
    … …  
    59415941
    59425942/* Line 1806 of yacc.c  */
    5943 #line 832 "parser.yy"
     5943#line 831 "parser.yy"
    59445944    { (yyval.sn) = 0; }
    59455945    break;
    … …  
    59485948
    59495949/* Line 1806 of yacc.c  */
    5950 #line 834 "parser.yy"
     5950#line 833 "parser.yy"
    59515951    { (yyval.sn) = 0; }
    59525952    break;
    … …  
    59555955
    59565956/* Line 1806 of yacc.c  */
    5957 #line 839 "parser.yy"
     5957#line 838 "parser.yy"
    59585958    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    59595959    break;
    … …  
    59625962
    59635963/* Line 1806 of yacc.c  */
    5964 #line 841 "parser.yy"
     5964#line 840 "parser.yy"
    59655965    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
    59665966    break;
    … …  
    59695969
    59705970/* Line 1806 of yacc.c  */
    5971 #line 843 "parser.yy"
     5971#line 842 "parser.yy"
    59725972    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
    59735973    break;
    … …  
    59765976
    59775977/* Line 1806 of yacc.c  */
    5978 #line 848 "parser.yy"
     5978#line 847 "parser.yy"
    59795979    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    59805980    break;
    … …  
    59835983
    59845984/* Line 1806 of yacc.c  */
    5985 #line 850 "parser.yy"
     5985#line 849 "parser.yy"
    59865986    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    59875987    break;
    … …  
    59905990
    59915991/* Line 1806 of yacc.c  */
    5992 #line 855 "parser.yy"
     5992#line 854 "parser.yy"
    59935993    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
    59945994    break;
    … …  
    59975997
    59985998/* Line 1806 of yacc.c  */
    5999 #line 859 "parser.yy"
     5999#line 858 "parser.yy"
    60006000    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
    60016001    break;
    … …  
    60046004
    60056005/* Line 1806 of yacc.c  */
    6006 #line 862 "parser.yy"
     6006#line 861 "parser.yy"
    60076007    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
    60086008    break;
    … …  
    60116011
    60126012/* Line 1806 of yacc.c  */
    6013 #line 866 "parser.yy"
     6013#line 865 "parser.yy"
    60146014    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
    60156015    break;
    … …  
    60186018
    60196019/* Line 1806 of yacc.c  */
    6020 #line 869 "parser.yy"
     6020#line 868 "parser.yy"
    60216021    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    60226022    break;
    … …  
    60256025
    60266026/* Line 1806 of yacc.c  */
    6027 #line 873 "parser.yy"
     6027#line 872 "parser.yy"
    60286028    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
    60296029    break;
    … …  
    60326032
    60336033/* Line 1806 of yacc.c  */
    6034 #line 875 "parser.yy"
     6034#line 874 "parser.yy"
    60356035    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
    60366036    break;
    … …  
    60396039
    60406040/* Line 1806 of yacc.c  */
    6041 #line 877 "parser.yy"
     6041#line 876 "parser.yy"
    60426042    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    60436043    break;
    … …  
    60466046
    60476047/* Line 1806 of yacc.c  */
    6048 #line 879 "parser.yy"
     6048#line 878 "parser.yy"
    60496049    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    60506050    break;
    … …  
    60536053
    60546054/* Line 1806 of yacc.c  */
    6055 #line 881 "parser.yy"
     6055#line 880 "parser.yy"
    60566056    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
    60576057    break;
    … …  
    60606060
    60616061/* Line 1806 of yacc.c  */
    6062 #line 886 "parser.yy"
     6062#line 885 "parser.yy"
    60636063    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
    60646064    break;
    … …  
    60676067
    60686068/* Line 1806 of yacc.c  */
    6069 #line 888 "parser.yy"
     6069#line 887 "parser.yy"
    60706070    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
    60716071    break;
    … …  
    60746074
    60756075/* Line 1806 of yacc.c  */
    6076 #line 890 "parser.yy"
     6076#line 889 "parser.yy"
    60776077    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
    60786078    break;
    … …  
    60816081
    60826082/* Line 1806 of yacc.c  */
    6083 #line 897 "parser.yy"
     6083#line 896 "parser.yy"
    60846084    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    60856085    break;
    … …  
    60886088
    60896089/* Line 1806 of yacc.c  */
    6090 #line 899 "parser.yy"
     6090#line 898 "parser.yy"
    60916091    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    60926092    break;
    … …  
    60956095
    60966096/* Line 1806 of yacc.c  */
    6097 #line 901 "parser.yy"
     6097#line 900 "parser.yy"
    60986098    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    60996099    break;
    … …  
    61026102
    61036103/* Line 1806 of yacc.c  */
    6104 #line 903 "parser.yy"
     6104#line 902 "parser.yy"
    61056105    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    61066106    break;
    … …  
    61096109
    61106110/* Line 1806 of yacc.c  */
    6111 #line 908 "parser.yy"
     6111#line 907 "parser.yy"
    61126112    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    61136113    break;
    … …  
    61166116
    61176117/* Line 1806 of yacc.c  */
    6118 #line 910 "parser.yy"
     6118#line 909 "parser.yy"
    61196119    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    61206120    break;
    … …  
    61236123
    61246124/* Line 1806 of yacc.c  */
    6125 #line 912 "parser.yy"
     6125#line 911 "parser.yy"
    61266126    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    61276127    break;
    … …  
    61306130
    61316131/* Line 1806 of yacc.c  */
    6132 #line 914 "parser.yy"
     6132#line 913 "parser.yy"
    61336133    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    61346134    break;
    … …  
    61376137
    61386138/* Line 1806 of yacc.c  */
    6139 #line 919 "parser.yy"
     6139#line 918 "parser.yy"
    61406140    {
    61416141                        (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
    … …  
    61466146
    61476147/* Line 1806 of yacc.c  */
    6148 #line 932 "parser.yy"
     6148#line 931 "parser.yy"
    61496149    {
    61506150                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    61566156
    61576157/* Line 1806 of yacc.c  */
    6158 #line 937 "parser.yy"
     6158#line 936 "parser.yy"
    61596159    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61606160    break;
    … …  
    61636163
    61646164/* Line 1806 of yacc.c  */
    6165 #line 939 "parser.yy"
     6165#line 938 "parser.yy"
    61666166    {
    61676167                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    61736173
    61746174/* Line 1806 of yacc.c  */
    6175 #line 948 "parser.yy"
     6175#line 947 "parser.yy"
    61766176    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
    61776177    break;
    … …  
    61806180
    61816181/* Line 1806 of yacc.c  */
    6182 #line 950 "parser.yy"
     6182#line 949 "parser.yy"
    61836183    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
    61846184    break;
    … …  
    61876187
    61886188/* Line 1806 of yacc.c  */
    6189 #line 952 "parser.yy"
     6189#line 951 "parser.yy"
    61906190    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
    61916191    break;
    … …  
    61946194
    61956195/* Line 1806 of yacc.c  */
    6196 #line 954 "parser.yy"
     6196#line 953 "parser.yy"
    61976197    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
    61986198    break;
    … …  
    62016201
    62026202/* Line 1806 of yacc.c  */
    6203 #line 956 "parser.yy"
     6203#line 955 "parser.yy"
    62046204    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); }
    62056205    break;
    … …  
    62086208
    62096209/* Line 1806 of yacc.c  */
    6210 #line 961 "parser.yy"
     6210#line 960 "parser.yy"
    62116211    { (yyval.flag) = false; }
    62126212    break;
    … …  
    62156215
    62166216/* Line 1806 of yacc.c  */
    6217 #line 963 "parser.yy"
     6217#line 962 "parser.yy"
    62186218    { (yyval.flag) = true; }
    62196219    break;
    … …  
    62226222
    62236223/* Line 1806 of yacc.c  */
    6224 #line 968 "parser.yy"
     6224#line 967 "parser.yy"
    62256225    { (yyval.en) = 0; }
    62266226    break;
    … …  
    62296229
    62306230/* Line 1806 of yacc.c  */
    6231 #line 975 "parser.yy"
     6231#line 974 "parser.yy"
    62326232    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    62336233    break;
    … …  
    62366236
    62376237/* Line 1806 of yacc.c  */
    6238 #line 980 "parser.yy"
     6238#line 979 "parser.yy"
    62396239    { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
    62406240    break;
    … …  
    62436243
    62446244/* Line 1806 of yacc.c  */
    6245 #line 982 "parser.yy"
     6245#line 981 "parser.yy"
    62466246    { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
    62476247    break;
    … …  
    62506250
    62516251/* Line 1806 of yacc.c  */
    6252 #line 987 "parser.yy"
     6252#line 986 "parser.yy"
    62536253    { (yyval.en) = 0; }
    62546254    break;
    … …  
    62576257
    62586258/* Line 1806 of yacc.c  */
    6259 #line 989 "parser.yy"
     6259#line 988 "parser.yy"
    62606260    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    62616261    break;
    … …  
    62646264
    62656265/* Line 1806 of yacc.c  */
    6266 #line 991 "parser.yy"
     6266#line 990 "parser.yy"
    62676267    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
    62686268    break;
    … …  
    62716271
    62726272/* Line 1806 of yacc.c  */
    6273 #line 996 "parser.yy"
     6273#line 995 "parser.yy"
    62746274    {
    62756275                        (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
    … …  
    62816281
    62826282/* Line 1806 of yacc.c  */
    6283 #line 1001 "parser.yy"
     6283#line 1000 "parser.yy"
    62846284    {
    62856285                        (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
    … …  
    62916291
    62926292/* Line 1806 of yacc.c  */
    6293 #line 1011 "parser.yy"
     6293#line 1010 "parser.yy"
    62946294    { (yyval.decl) = 0; }
    62956295    break;
    … …  
    62986298
    62996299/* Line 1806 of yacc.c  */
    6300 #line 1018 "parser.yy"
     6300#line 1017 "parser.yy"
    63016301    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63026302    break;
    … …  
    63056305
    63066306/* Line 1806 of yacc.c  */
    6307 #line 1023 "parser.yy"
     6307#line 1022 "parser.yy"
    63086308    { (yyval.decl) = 0; }
    63096309    break;
    … …  
    63126312
    63136313/* Line 1806 of yacc.c  */
    6314 #line 1030 "parser.yy"
     6314#line 1029 "parser.yy"
    63156315    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63166316    break;
    63176317
    63186318  case 247:
     6319
     6320/* Line 1806 of yacc.c  */
     6321#line 1043 "parser.yy"
     6322    {}
     6323    break;
     6324
     6325  case 248:
    63196326
    63206327/* Line 1806 of yacc.c  */
    … …  
    63236330    break;
    63246331
    6325   case 248:
    6326 
    6327 /* Line 1806 of yacc.c  */
    6328 #line 1045 "parser.yy"
    6329     {}
    6330     break;
    6331 
    63326332  case 256:
    63336333
    63346334/* Line 1806 of yacc.c  */
    6335 #line 1074 "parser.yy"
     6335#line 1073 "parser.yy"
    63366336    {
    63376337                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63436343
    63446344/* Line 1806 of yacc.c  */
    6345 #line 1081 "parser.yy"
     6345#line 1080 "parser.yy"
    63466346    {
    63476347                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63536353
    63546354/* Line 1806 of yacc.c  */
    6355 #line 1086 "parser.yy"
     6355#line 1085 "parser.yy"
    63566356    {
    63576357                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
    … …  
    63636363
    63646364/* Line 1806 of yacc.c  */
    6365 #line 1096 "parser.yy"
     6365#line 1095 "parser.yy"
    63666366    {
    63676367                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    63736373
    63746374/* Line 1806 of yacc.c  */
    6375 #line 1101 "parser.yy"
     6375#line 1100 "parser.yy"
    63766376    {
    63776377                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    63836383
    63846384/* Line 1806 of yacc.c  */
    6385 #line 1106 "parser.yy"
     6385#line 1105 "parser.yy"
    63866386    {
    63876387                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
    … …  
    63936393
    63946394/* Line 1806 of yacc.c  */
    6395 #line 1114 "parser.yy"
     6395#line 1113 "parser.yy"
    63966396    {
    63976397                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64036403
    64046404/* Line 1806 of yacc.c  */
    6405 #line 1119 "parser.yy"
     6405#line 1118 "parser.yy"
    64066406    {
    64076407                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64136413
    64146414/* Line 1806 of yacc.c  */
    6415 #line 1124 "parser.yy"
     6415#line 1123 "parser.yy"
    64166416    {
    64176417                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64236423
    64246424/* Line 1806 of yacc.c  */
    6425 #line 1129 "parser.yy"
     6425#line 1128 "parser.yy"
    64266426    {
    64276427                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64336433
    64346434/* Line 1806 of yacc.c  */
    6435 #line 1134 "parser.yy"
     6435#line 1133 "parser.yy"
    64366436    {
    64376437                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    64436443
    64446444/* Line 1806 of yacc.c  */
    6445 #line 1142 "parser.yy"
     6445#line 1141 "parser.yy"
    64466446    {
    64476447                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
    … …  
    64526452
    64536453/* Line 1806 of yacc.c  */
    6454 #line 1165 "parser.yy"
     6454#line 1164 "parser.yy"
    64556455    {
    64566456                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    64616461
    64626462/* Line 1806 of yacc.c  */
    6463 #line 1169 "parser.yy"
     6463#line 1168 "parser.yy"
    64646464    {
    64656465                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    64706470
    64716471/* Line 1806 of yacc.c  */
    6472 #line 1176 "parser.yy"
     6472#line 1175 "parser.yy"
    64736473    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64746474    break;
    … …  
    64776477
    64786478/* Line 1806 of yacc.c  */
    6479 #line 1180 "parser.yy"
     6479#line 1179 "parser.yy"
    64806480    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64816481    break;
    … …  
    64846484
    64856485/* Line 1806 of yacc.c  */
    6486 #line 1185 "parser.yy"
     6486#line 1184 "parser.yy"
    64876487    {
    64886488                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    64946494
    64956495/* Line 1806 of yacc.c  */
    6496 #line 1190 "parser.yy"
     6496#line 1189 "parser.yy"
    64976497    {
    64986498                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65046504
    65056505/* Line 1806 of yacc.c  */
    6506 #line 1195 "parser.yy"
     6506#line 1194 "parser.yy"
    65076507    {
    65086508                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
    … …  
    65146514
    65156515/* Line 1806 of yacc.c  */
    6516 #line 1206 "parser.yy"
     6516#line 1205 "parser.yy"
    65176517    {
    65186518                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65246524
    65256525/* Line 1806 of yacc.c  */
    6526 #line 1211 "parser.yy"
     6526#line 1210 "parser.yy"
    65276527    {
    65286528                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65346534
    65356535/* Line 1806 of yacc.c  */
    6536 #line 1216 "parser.yy"
     6536#line 1215 "parser.yy"
    65376537    {
    65386538                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65446544
    65456545/* Line 1806 of yacc.c  */
    6546 #line 1221 "parser.yy"
     6546#line 1220 "parser.yy"
    65476547    {
    65486548                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65546554
    65556555/* Line 1806 of yacc.c  */
    6556 #line 1226 "parser.yy"
     6556#line 1225 "parser.yy"
    65576557    {
    65586558                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65646564
    65656565/* Line 1806 of yacc.c  */
    6566 #line 1235 "parser.yy"
     6566#line 1234 "parser.yy"
    65676567    {
    65686568                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
    … …  
    65746574
    65756575/* Line 1806 of yacc.c  */
    6576 #line 1240 "parser.yy"
     6576#line 1239 "parser.yy"
    65776577    {
    65786578                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
    … …  
    65846584
    65856585/* Line 1806 of yacc.c  */
    6586 #line 1257 "parser.yy"
     6586#line 1256 "parser.yy"
    65876587    {
    65886588                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    65946594
    65956595/* Line 1806 of yacc.c  */
    6596 #line 1262 "parser.yy"
     6596#line 1261 "parser.yy"
    65976597    {
    65986598                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    66046604
    66056605/* Line 1806 of yacc.c  */
    6606 #line 1284 "parser.yy"
     6606#line 1283 "parser.yy"
    66076607    { (yyval.decl) = 0; }
    66086608    break;
    … …  
    66116611
    66126612/* Line 1806 of yacc.c  */
    6613 #line 1296 "parser.yy"
     6613#line 1295 "parser.yy"
    66146614    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66156615    break;
    … …  
    66186618
    66196619/* Line 1806 of yacc.c  */
    6620 #line 1307 "parser.yy"
     6620#line 1306 "parser.yy"
    66216621    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    66226622    break;
    … …  
    66256625
    66266626/* Line 1806 of yacc.c  */
    6627 #line 1309 "parser.yy"
     6627#line 1308 "parser.yy"
    66286628    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    66296629    break;
    … …  
    66326632
    66336633/* Line 1806 of yacc.c  */
    6634 #line 1311 "parser.yy"
     6634#line 1310 "parser.yy"
    66356635    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    66366636    break;
    … …  
    66396639
    66406640/* Line 1806 of yacc.c  */
    6641 #line 1313 "parser.yy"
     6641#line 1312 "parser.yy"
    66426642    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    66436643    break;
    … …  
    66466646
    66476647/* Line 1806 of yacc.c  */
    6648 #line 1315 "parser.yy"
     6648#line 1314 "parser.yy"
    66496649    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    66506650    break;
    … …  
    66536653
    66546654/* Line 1806 of yacc.c  */
    6655 #line 1317 "parser.yy"
     6655#line 1316 "parser.yy"
    66566656    {
    66576657                        typedefTable.enterScope();
    … …  
    66626662
    66636663/* Line 1806 of yacc.c  */
    6664 #line 1321 "parser.yy"
     6664#line 1320 "parser.yy"
    66656665    {
    66666666                        typedefTable.leaveScope();
    … …  
    66726672
    66736673/* Line 1806 of yacc.c  */
    6674 #line 1330 "parser.yy"
     6674#line 1329 "parser.yy"
    66756675    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66766676    break;
    … …  
    66796679
    66806680/* Line 1806 of yacc.c  */
    6681 #line 1332 "parser.yy"
     6681#line 1331 "parser.yy"
    66826682    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66836683    break;
    … …  
    66866686
    66876687/* Line 1806 of yacc.c  */
    6688 #line 1343 "parser.yy"
     6688#line 1342 "parser.yy"
    66896689    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66906690    break;
    … …  
    66936693
    66946694/* Line 1806 of yacc.c  */
    6695 #line 1348 "parser.yy"
     6695#line 1347 "parser.yy"
    66966696    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    66976697    break;
    … …  
    67006700
    67016701/* Line 1806 of yacc.c  */
    6702 #line 1350 "parser.yy"
     6702#line 1349 "parser.yy"
    67036703    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    67046704    break;
    … …  
    67076707
    67086708/* Line 1806 of yacc.c  */
    6709 #line 1352 "parser.yy"
     6709#line 1351 "parser.yy"
    67106710    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    67116711    break;
    … …  
    67146714
    67156715/* Line 1806 of yacc.c  */
    6716 #line 1354 "parser.yy"
     6716#line 1353 "parser.yy"
    67176717    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    67186718    break;
    … …  
    67216721
    67226722/* Line 1806 of yacc.c  */
    6723 #line 1357 "parser.yy"
     6723#line 1356 "parser.yy"
    67246724    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
    67256725    break;
    … …  
    67286728
    67296729/* Line 1806 of yacc.c  */
    6730 #line 1359 "parser.yy"
     6730#line 1358 "parser.yy"
    67316731    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    67326732    break;
    … …  
    67356735
    67366736/* Line 1806 of yacc.c  */
    6737 #line 1362 "parser.yy"
     6737#line 1361 "parser.yy"
    67386738    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
    67396739    break;
    … …  
    67426742
    67436743/* Line 1806 of yacc.c  */
    6744 #line 1364 "parser.yy"
     6744#line 1363 "parser.yy"
    67456745    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    67466746    break;
    … …  
    67496749
    67506750/* Line 1806 of yacc.c  */
    6751 #line 1369 "parser.yy"
     6751#line 1368 "parser.yy"
    67526752    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    67536753    break;
    … …  
    67566756
    67576757/* Line 1806 of yacc.c  */
    6758 #line 1371 "parser.yy"
     6758#line 1370 "parser.yy"
    67596759    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    67606760    break;
    … …  
    67636763
    67646764/* Line 1806 of yacc.c  */
    6765 #line 1373 "parser.yy"
     6765#line 1372 "parser.yy"
    67666766    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    67676767    break;
    … …  
    67706770
    67716771/* Line 1806 of yacc.c  */
    6772 #line 1375 "parser.yy"
     6772#line 1374 "parser.yy"
    67736773    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    67746774    break;
    … …  
    67776777
    67786778/* Line 1806 of yacc.c  */
    6779 #line 1377 "parser.yy"
     6779#line 1376 "parser.yy"
    67806780    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
    67816781    break;
    … …  
    67846784
    67856785/* Line 1806 of yacc.c  */
    6786 #line 1379 "parser.yy"
     6786#line 1378 "parser.yy"
    67876787    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
    67886788    break;
    … …  
    67916791
    67926792/* Line 1806 of yacc.c  */
    6793 #line 1381 "parser.yy"
     6793#line 1380 "parser.yy"
    67946794    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
    67956795    break;
    … …  
    67986798
    67996799/* Line 1806 of yacc.c  */
    6800 #line 1383 "parser.yy"
     6800#line 1382 "parser.yy"
    68016801    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
    68026802    break;
    … …  
    68056805
    68066806/* Line 1806 of yacc.c  */
    6807 #line 1385 "parser.yy"
     6807#line 1384 "parser.yy"
    68086808    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    68096809    break;
    … …  
    68126812
    68136813/* Line 1806 of yacc.c  */
    6814 #line 1387 "parser.yy"
     6814#line 1386 "parser.yy"
    68156815    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    68166816    break;
    … …  
    68196819
    68206820/* Line 1806 of yacc.c  */
    6821 #line 1389 "parser.yy"
     6821#line 1388 "parser.yy"
    68226822    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
    68236823    break;
    … …  
    68266826
    68276827/* Line 1806 of yacc.c  */
    6828 #line 1391 "parser.yy"
     6828#line 1390 "parser.yy"
    68296829    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
    68306830    break;
    … …  
    68336833
    68346834/* Line 1806 of yacc.c  */
    6835 #line 1393 "parser.yy"
     6835#line 1392 "parser.yy"
    68366836    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    68376837    break;
    … …  
    68406840
    68416841/* Line 1806 of yacc.c  */
    6842 #line 1400 "parser.yy"
     6842#line 1399 "parser.yy"
    68436843    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68446844    break;
    … …  
    68476847
    68486848/* Line 1806 of yacc.c  */
    6849 #line 1402 "parser.yy"
     6849#line 1401 "parser.yy"
    68506850    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68516851    break;
    … …  
    68546854
    68556855/* Line 1806 of yacc.c  */
    6856 #line 1404 "parser.yy"
     6856#line 1403 "parser.yy"
    68576857    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68586858    break;
    … …  
    68616861
    68626862/* Line 1806 of yacc.c  */
    6863 #line 1406 "parser.yy"
     6863#line 1405 "parser.yy"
    68646864    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    68656865    break;
    … …  
    68686868
    68696869/* Line 1806 of yacc.c  */
    6870 #line 1412 "parser.yy"
     6870#line 1411 "parser.yy"
    68716871    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68726872    break;
    … …  
    68756875
    68766876/* Line 1806 of yacc.c  */
    6877 #line 1419 "parser.yy"
     6877#line 1418 "parser.yy"
    68786878    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68796879    break;
    … …  
    68826882
    68836883/* Line 1806 of yacc.c  */
    6884 #line 1421 "parser.yy"
     6884#line 1420 "parser.yy"
    68856885    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68866886    break;
    … …  
    68896889
    68906890/* Line 1806 of yacc.c  */
    6891 #line 1423 "parser.yy"
     6891#line 1422 "parser.yy"
    68926892    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    68936893    break;
    … …  
    68966896
    68976897/* Line 1806 of yacc.c  */
    6898 #line 1428 "parser.yy"
     6898#line 1427 "parser.yy"
    68996899    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    69006900    break;
    … …  
    69036903
    69046904/* Line 1806 of yacc.c  */
    6905 #line 1430 "parser.yy"
     6905#line 1429 "parser.yy"
    69066906    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    69076907    break;
    … …  
    69106910
    69116911/* Line 1806 of yacc.c  */
    6912 #line 1432 "parser.yy"
     6912#line 1431 "parser.yy"
    69136913    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    69146914    break;
    … …  
    69176917
    69186918/* Line 1806 of yacc.c  */
    6919 #line 1434 "parser.yy"
     6919#line 1433 "parser.yy"
    69206920    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    69216921    break;
    … …  
    69246924
    69256925/* Line 1806 of yacc.c  */
    6926 #line 1440 "parser.yy"
     6926#line 1439 "parser.yy"
    69276927    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69286928    break;
    … …  
    69316931
    69326932/* Line 1806 of yacc.c  */
    6933 #line 1442 "parser.yy"
     6933#line 1441 "parser.yy"
    69346934    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69356935    break;
    … …  
    69386938
    69396939/* Line 1806 of yacc.c  */
    6940 #line 1444 "parser.yy"
     6940#line 1443 "parser.yy"
    69416941    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69426942    break;
    … …  
    69456945
    69466946/* Line 1806 of yacc.c  */
    6947 #line 1450 "parser.yy"
     6947#line 1449 "parser.yy"
    69486948    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69496949    break;
    … …  
    69526952
    69536953/* Line 1806 of yacc.c  */
    6954 #line 1452 "parser.yy"
     6954#line 1451 "parser.yy"
    69556955    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69566956    break;
    … …  
    69596959
    69606960/* Line 1806 of yacc.c  */
    6961 #line 1458 "parser.yy"
     6961#line 1457 "parser.yy"
    69626962    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69636963    break;
    … …  
    69666966
    69676967/* Line 1806 of yacc.c  */
    6968 #line 1460 "parser.yy"
     6968#line 1459 "parser.yy"
    69696969    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69706970    break;
    … …  
    69736973
    69746974/* Line 1806 of yacc.c  */
    6975 #line 1462 "parser.yy"
     6975#line 1461 "parser.yy"
    69766976    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69776977    break;
    … …  
    69806980
    69816981/* Line 1806 of yacc.c  */
    6982 #line 1467 "parser.yy"
     6982#line 1466 "parser.yy"
    69836983    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    69846984    break;
    … …  
    69876987
    69886988/* Line 1806 of yacc.c  */
    6989 #line 1469 "parser.yy"
     6989#line 1468 "parser.yy"
    69906990    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69916991    break;
    … …  
    69946994
    69956995/* Line 1806 of yacc.c  */
    6996 #line 1471 "parser.yy"
     6996#line 1470 "parser.yy"
    69976997    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69986998    break;
    … …  
    70017001
    70027002/* Line 1806 of yacc.c  */
    7003 #line 1481 "parser.yy"
     7003#line 1480 "parser.yy"
    70047004    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); }
    70057005    break;
    … …  
    70087008
    70097009/* Line 1806 of yacc.c  */
    7010 #line 1483 "parser.yy"
     7010#line 1482 "parser.yy"
    70117011    {
    70127012                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    70187018
    70197019/* Line 1806 of yacc.c  */
    7020 #line 1488 "parser.yy"
     7020#line 1487 "parser.yy"
    70217021    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70227022    break;
    … …  
    70257025
    70267026/* Line 1806 of yacc.c  */
    7027 #line 1490 "parser.yy"
     7027#line 1489 "parser.yy"
    70287028    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
    70297029    break;
    … …  
    70327032
    70337033/* Line 1806 of yacc.c  */
    7034 #line 1492 "parser.yy"
     7034#line 1491 "parser.yy"
    70357035    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    70367036    break;
    … …  
    70397039
    70407040/* Line 1806 of yacc.c  */
    7041 #line 1494 "parser.yy"
     7041#line 1493 "parser.yy"
    70427042    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    70437043    break;
    … …  
    70467046
    70477047/* Line 1806 of yacc.c  */
    7048 #line 1499 "parser.yy"
     7048#line 1498 "parser.yy"
    70497049    { (yyval.aggKey) = DeclarationNode::Struct; }
    70507050    break;
    … …  
    70537053
    70547054/* Line 1806 of yacc.c  */
    7055 #line 1501 "parser.yy"
     7055#line 1500 "parser.yy"
    70567056    { (yyval.aggKey) = DeclarationNode::Union; }
    70577057    break;
    … …  
    70607060
    70617061/* Line 1806 of yacc.c  */
    7062 #line 1506 "parser.yy"
     7062#line 1505 "parser.yy"
    70637063    { (yyval.decl) = 0; }
    70647064    break;
    … …  
    70677067
    70687068/* Line 1806 of yacc.c  */
    7069 #line 1508 "parser.yy"
     7069#line 1507 "parser.yy"
    70707070    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    70717071    break;
    … …  
    70747074
    70757075/* Line 1806 of yacc.c  */
    7076 #line 1514 "parser.yy"
     7076#line 1513 "parser.yy"
    70777077    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70787078    break;
    … …  
    70817081
    70827082/* Line 1806 of yacc.c  */
    7083 #line 1517 "parser.yy"
     7083#line 1516 "parser.yy"
    70847084    {   // mark all fields in list
    70857085                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    70927092
    70937093/* Line 1806 of yacc.c  */
    7094 #line 1527 "parser.yy"
     7094#line 1526 "parser.yy"
    70957095    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70967096    break;
    … …  
    70997099
    71007100/* Line 1806 of yacc.c  */
    7101 #line 1529 "parser.yy"
     7101#line 1528 "parser.yy"
    71027102    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    71037103    break;
    … …  
    71067106
    71077107/* Line 1806 of yacc.c  */
    7108 #line 1531 "parser.yy"
     7108#line 1530 "parser.yy"
    71097109    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    71107110    break;
    … …  
    71137113
    71147114/* Line 1806 of yacc.c  */
    7115 #line 1536 "parser.yy"
     7115#line 1535 "parser.yy"
    71167116    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    71177117    break;
    … …  
    71207120
    71217121/* Line 1806 of yacc.c  */
    7122 #line 1538 "parser.yy"
     7122#line 1537 "parser.yy"
    71237123    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    71247124    break;
    … …  
    71277127
    71287128/* Line 1806 of yacc.c  */
    7129 #line 1543 "parser.yy"
     7129#line 1542 "parser.yy"
    71307130    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    71317131    break;
    … …  
    71347134
    71357135/* Line 1806 of yacc.c  */
    7136 #line 1545 "parser.yy"
     7136#line 1544 "parser.yy"
    71377137    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    71387138    break;
    … …  
    71417141
    71427142/* Line 1806 of yacc.c  */
    7143 #line 1548 "parser.yy"
     7143#line 1547 "parser.yy"
    71447144    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    71457145    break;
    … …  
    71487148
    71497149/* Line 1806 of yacc.c  */
    7150 #line 1551 "parser.yy"
     7150#line 1550 "parser.yy"
    71517151    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    71527152    break;
    … …  
    71557155
    71567156/* Line 1806 of yacc.c  */
    7157 #line 1557 "parser.yy"
     7157#line 1556 "parser.yy"
    71587158    { (yyval.en) = 0; }
    71597159    break;
    … …  
    71627162
    71637163/* Line 1806 of yacc.c  */
    7164 #line 1559 "parser.yy"
     7164#line 1558 "parser.yy"
    71657165    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71667166    break;
    … …  
    71697169
    71707170/* Line 1806 of yacc.c  */
    7171 #line 1564 "parser.yy"
     7171#line 1563 "parser.yy"
    71727172    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71737173    break;
    … …  
    71767176
    71777177/* Line 1806 of yacc.c  */
    7178 #line 1573 "parser.yy"
     7178#line 1572 "parser.yy"
    71797179    { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
    71807180    break;
    … …  
    71837183
    71847184/* Line 1806 of yacc.c  */
    7185 #line 1575 "parser.yy"
     7185#line 1574 "parser.yy"
    71867186    {
    71877187                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    71937193
    71947194/* Line 1806 of yacc.c  */
    7195 #line 1580 "parser.yy"
     7195#line 1579 "parser.yy"
    71967196    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71977197    break;
    … …  
    72007200
    72017201/* Line 1806 of yacc.c  */
    7202 #line 1582 "parser.yy"
     7202#line 1581 "parser.yy"
    72037203    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    72047204    break;
    … …  
    72077207
    72087208/* Line 1806 of yacc.c  */
    7209 #line 1587 "parser.yy"
     7209#line 1586 "parser.yy"
    72107210    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    72117211    break;
    … …  
    72147214
    72157215/* Line 1806 of yacc.c  */
    7216 #line 1589 "parser.yy"
     7216#line 1588 "parser.yy"
    72177217    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    72187218    break;
    … …  
    72217221
    72227222/* Line 1806 of yacc.c  */
    7223 #line 1594 "parser.yy"
     7223#line 1593 "parser.yy"
    72247224    { (yyval.en) = 0; }
    72257225    break;
    … …  
    72287228
    72297229/* Line 1806 of yacc.c  */
    7230 #line 1596 "parser.yy"
     7230#line 1595 "parser.yy"
    72317231    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    72327232    break;
    … …  
    72357235
    72367236/* Line 1806 of yacc.c  */
    7237 #line 1603 "parser.yy"
     7237#line 1602 "parser.yy"
    72387238    { (yyval.decl) = 0; }
    72397239    break;
    … …  
    72427242
    72437243/* Line 1806 of yacc.c  */
    7244 #line 1611 "parser.yy"
     7244#line 1610 "parser.yy"
    72457245    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72467246    break;
    … …  
    72497249
    72507250/* Line 1806 of yacc.c  */
    7251 #line 1613 "parser.yy"
     7251#line 1612 "parser.yy"
    72527252    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72537253    break;
    … …  
    72567256
    72577257/* Line 1806 of yacc.c  */
    7258 #line 1615 "parser.yy"
     7258#line 1614 "parser.yy"
    72597259    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72607260    break;
    … …  
    72637263
    72647264/* Line 1806 of yacc.c  */
    7265 #line 1623 "parser.yy"
     7265#line 1622 "parser.yy"
    72667266    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72677267    break;
    … …  
    72707270
    72717271/* Line 1806 of yacc.c  */
    7272 #line 1625 "parser.yy"
     7272#line 1624 "parser.yy"
    72737273    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72747274    break;
    … …  
    72777277
    72787278/* Line 1806 of yacc.c  */
    7279 #line 1627 "parser.yy"
     7279#line 1626 "parser.yy"
    72807280    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    72817281    break;
    … …  
    72847284
    72857285/* Line 1806 of yacc.c  */
    7286 #line 1633 "parser.yy"
     7286#line 1632 "parser.yy"
    72877287    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72887288    break;
    … …  
    72917291
    72927292/* Line 1806 of yacc.c  */
    7293 #line 1638 "parser.yy"
     7293#line 1637 "parser.yy"
    72947294    { (yyval.decl) = 0; }
    72957295    break;
    … …  
    72987298
    72997299/* Line 1806 of yacc.c  */
    7300 #line 1645 "parser.yy"
     7300#line 1644 "parser.yy"
    73017301    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    73027302    break;
    … …  
    73057305
    73067306/* Line 1806 of yacc.c  */
    7307 #line 1652 "parser.yy"
     7307#line 1651 "parser.yy"
    73087308    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    73097309    break;
    … …  
    73127312
    73137313/* Line 1806 of yacc.c  */
    7314 #line 1654 "parser.yy"
     7314#line 1653 "parser.yy"
    73157315    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    73167316    break;
    … …  
    73197319
    73207320/* Line 1806 of yacc.c  */
    7321 #line 1663 "parser.yy"
     7321#line 1662 "parser.yy"
    73227322    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    73237323    break;
    … …  
    73267326
    73277327/* Line 1806 of yacc.c  */
    7328 #line 1666 "parser.yy"
     7328#line 1665 "parser.yy"
    73297329    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    73307330    break;
    … …  
    73337333
    73347334/* Line 1806 of yacc.c  */
    7335 #line 1668 "parser.yy"
     7335#line 1667 "parser.yy"
    73367336    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    73377337    break;
    … …  
    73407340
    73417341/* Line 1806 of yacc.c  */
    7342 #line 1678 "parser.yy"
     7342#line 1677 "parser.yy"
    73437343    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    73447344    break;
    … …  
    73477347
    73487348/* Line 1806 of yacc.c  */
    7349 #line 1684 "parser.yy"
     7349#line 1683 "parser.yy"
    73507350    {
    73517351                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    73577357
    73587358/* Line 1806 of yacc.c  */
    7359 #line 1689 "parser.yy"
     7359#line 1688 "parser.yy"
    73607360    {
    73617361                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    73677367
    73687368/* Line 1806 of yacc.c  */
    7369 #line 1698 "parser.yy"
     7369#line 1697 "parser.yy"
    73707370    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73717371    break;
    … …  
    73747374
    73757375/* Line 1806 of yacc.c  */
    7376 #line 1707 "parser.yy"
     7376#line 1706 "parser.yy"
    73777377    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73787378    break;
    … …  
    73817381
    73827382/* Line 1806 of yacc.c  */
    7383 #line 1709 "parser.yy"
     7383#line 1708 "parser.yy"
    73847384    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73857385    break;
    … …  
    73887388
    73897389/* Line 1806 of yacc.c  */
    7390 #line 1734 "parser.yy"
     7390#line 1733 "parser.yy"
    73917391    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73927392    break;
    … …  
    73957395
    73967396/* Line 1806 of yacc.c  */
    7397 #line 1742 "parser.yy"
     7397#line 1741 "parser.yy"
    73987398    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73997399    break;
    … …  
    74027402
    74037403/* Line 1806 of yacc.c  */
    7404 #line 1747 "parser.yy"
     7404#line 1746 "parser.yy"
    74057405    { (yyval.in) = 0; }
    74067406    break;
    … …  
    74097409
    74107410/* Line 1806 of yacc.c  */
    7411 #line 1749 "parser.yy"
     7411#line 1748 "parser.yy"
    74127412    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    74137413    break;
    … …  
    74167416
    74177417/* Line 1806 of yacc.c  */
    7418 #line 1751 "parser.yy"
     7418#line 1750 "parser.yy"
    74197419    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    74207420    break;
    … …  
    74237423
    74247424/* Line 1806 of yacc.c  */
     7425#line 1754 "parser.yy"
     7426    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
     7427    break;
     7428
     7429  case 460:
     7430
     7431/* Line 1806 of yacc.c  */
    74257432#line 1755 "parser.yy"
    7426     { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    7427     break;
    7428 
    7429   case 460:
    7430 
    7431 /* Line 1806 of yacc.c  */
    7432 #line 1756 "parser.yy"
    74337433    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    74347434    break;
    … …  
    74377437
    74387438/* Line 1806 of yacc.c  */
    7439 #line 1761 "parser.yy"
     7439#line 1760 "parser.yy"
    74407440    { (yyval.in) = 0; }
    74417441    break;
    … …  
    74447444
    74457445/* Line 1806 of yacc.c  */
     7446#line 1762 "parser.yy"
     7447    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     7448    break;
     7449
     7450  case 464:
     7451
     7452/* Line 1806 of yacc.c  */
    74467453#line 1763 "parser.yy"
    7447     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    7448     break;
    7449 
    7450   case 464:
    7451 
    7452 /* Line 1806 of yacc.c  */
    7453 #line 1764 "parser.yy"
    74547454    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
    74557455    break;
    … …  
    74587458
    74597459/* Line 1806 of yacc.c  */
    7460 #line 1766 "parser.yy"
     7460#line 1765 "parser.yy"
    74617461    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    74627462    break;
    … …  
    74657465
    74667466/* Line 1806 of yacc.c  */
    7467 #line 1782 "parser.yy"
     7467#line 1781 "parser.yy"
    74687468    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    74697469    break;
    … …  
    74727472
    74737473/* Line 1806 of yacc.c  */
    7474 #line 1788 "parser.yy"
     7474#line 1787 "parser.yy"
    74757475    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
    74767476    break;
    … …  
    74797479
    74807480/* Line 1806 of yacc.c  */
    7481 #line 1794 "parser.yy"
     7481#line 1793 "parser.yy"
    74827482    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    74837483    break;
    … …  
    74867486
    74877487/* Line 1806 of yacc.c  */
    7488 #line 1797 "parser.yy"
     7488#line 1796 "parser.yy"
    74897489    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74907490    break;
    … …  
    74937493
    74947494/* Line 1806 of yacc.c  */
    7495 #line 1799 "parser.yy"
     7495#line 1798 "parser.yy"
    74967496    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74977497    break;
    … …  
    75007500
    75017501/* Line 1806 of yacc.c  */
    7502 #line 1801 "parser.yy"
     7502#line 1800 "parser.yy"
    75037503    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
    75047504    break;
    … …  
    75077507
    75087508/* Line 1806 of yacc.c  */
    7509 #line 1803 "parser.yy"
     7509#line 1802 "parser.yy"
    75107510    { (yyval.en) = (yyvsp[(4) - (6)].en); }
    75117511    break;
    … …  
    75147514
    75157515/* Line 1806 of yacc.c  */
    7516 #line 1827 "parser.yy"
     7516#line 1826 "parser.yy"
    75177517    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75187518    break;
    … …  
    75217521
    75227522/* Line 1806 of yacc.c  */
    7523 #line 1829 "parser.yy"
     7523#line 1828 "parser.yy"
    75247524    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75257525    break;
    … …  
    75287528
    75297529/* Line 1806 of yacc.c  */
    7530 #line 1831 "parser.yy"
     7530#line 1830 "parser.yy"
    75317531    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    75327532    break;
    … …  
    75357535
    75367536/* Line 1806 of yacc.c  */
    7537 #line 1837 "parser.yy"
     7537#line 1836 "parser.yy"
    75387538    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75397539    break;
    … …  
    75427542
    75437543/* Line 1806 of yacc.c  */
    7544 #line 1839 "parser.yy"
     7544#line 1838 "parser.yy"
    75457545    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75467546    break;
    … …  
    75497549
    75507550/* Line 1806 of yacc.c  */
    7551 #line 1844 "parser.yy"
     7551#line 1843 "parser.yy"
    75527552    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    75537553    break;
    … …  
    75567556
    75577557/* Line 1806 of yacc.c  */
    7558 #line 1850 "parser.yy"
     7558#line 1849 "parser.yy"
    75597559    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75607560    break;
    … …  
    75637563
    75647564/* Line 1806 of yacc.c  */
    7565 #line 1855 "parser.yy"
     7565#line 1854 "parser.yy"
    75667566    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75677567    break;
    … …  
    75707570
    75717571/* Line 1806 of yacc.c  */
    7572 #line 1857 "parser.yy"
     7572#line 1856 "parser.yy"
    75737573    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    75747574    break;
    … …  
    75777577
    75787578/* Line 1806 of yacc.c  */
    7579 #line 1863 "parser.yy"
     7579#line 1862 "parser.yy"
    75807580    { (yyval.tclass) = DeclarationNode::Otype; }
    75817581    break;
    … …  
    75847584
    75857585/* Line 1806 of yacc.c  */
    7586 #line 1865 "parser.yy"
     7586#line 1864 "parser.yy"
    75877587    { (yyval.tclass) = DeclarationNode::Ftype; }
    75887588    break;
    … …  
    75917591
    75927592/* Line 1806 of yacc.c  */
    7593 #line 1867 "parser.yy"
     7593#line 1866 "parser.yy"
    75947594    { (yyval.tclass) = DeclarationNode::Dtype; }
    75957595    break;
    … …  
    75987598
    75997599/* Line 1806 of yacc.c  */
    7600 #line 1872 "parser.yy"
     7600#line 1871 "parser.yy"
    76017601    { (yyval.decl) = 0; }
    76027602    break;
    … …  
    76057605
    76067606/* Line 1806 of yacc.c  */
    7607 #line 1874 "parser.yy"
     7607#line 1873 "parser.yy"
    76087608    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    76097609    break;
    … …  
    76127612
    76137613/* Line 1806 of yacc.c  */
    7614 #line 1879 "parser.yy"
     7614#line 1878 "parser.yy"
    76157615    {
    76167616                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
    … …  
    76227622
    76237623/* Line 1806 of yacc.c  */
    7624 #line 1884 "parser.yy"
     7624#line 1883 "parser.yy"
    76257625    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    76267626    break;
    … …  
    76297629
    76307630/* Line 1806 of yacc.c  */
    7631 #line 1886 "parser.yy"
     7631#line 1885 "parser.yy"
    76327632    { (yyval.decl) = 0; }
    76337633    break;
    … …  
    76367636
    76377637/* Line 1806 of yacc.c  */
    7638 #line 1891 "parser.yy"
     7638#line 1890 "parser.yy"
    76397639    { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
    76407640    break;
    … …  
    76437643
    76447644/* Line 1806 of yacc.c  */
    7645 #line 1894 "parser.yy"
     7645#line 1893 "parser.yy"
    76467646    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
    76477647    break;
    … …  
    76507650
    76517651/* Line 1806 of yacc.c  */
    7652 #line 1896 "parser.yy"
     7652#line 1895 "parser.yy"
    76537653    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    76547654    break;
    … …  
    76577657
    76587658/* Line 1806 of yacc.c  */
    7659 #line 1901 "parser.yy"
     7659#line 1900 "parser.yy"
    76607660    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76617661    break;
    … …  
    76647664
    76657665/* Line 1806 of yacc.c  */
    7666 #line 1903 "parser.yy"
     7666#line 1902 "parser.yy"
    76677667    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76687668    break;
    … …  
    76717671
    76727672/* Line 1806 of yacc.c  */
    7673 #line 1905 "parser.yy"
     7673#line 1904 "parser.yy"
    76747674    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76757675    break;
    … …  
    76787678
    76797679/* Line 1806 of yacc.c  */
    7680 #line 1910 "parser.yy"
     7680#line 1909 "parser.yy"
    76817681    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76827682    break;
    … …  
    76857685
    76867686/* Line 1806 of yacc.c  */
    7687 #line 1912 "parser.yy"
     7687#line 1911 "parser.yy"
    76887688    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76897689    break;
    … …  
    76927692
    76937693/* Line 1806 of yacc.c  */
    7694 #line 1917 "parser.yy"
     7694#line 1916 "parser.yy"
    76957695    {
    76967696                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
    … …  
    77027702
    77037703/* Line 1806 of yacc.c  */
    7704 #line 1922 "parser.yy"
     7704#line 1921 "parser.yy"
    77057705    {
    77067706                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
    … …  
    77127712
    77137713/* Line 1806 of yacc.c  */
    7714 #line 1930 "parser.yy"
     7714#line 1929 "parser.yy"
    77157715    {
    77167716                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
    … …  
    77227722
    77237723/* Line 1806 of yacc.c  */
    7724 #line 1935 "parser.yy"
     7724#line 1934 "parser.yy"
    77257725    {
    77267726                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
    … …  
    77327732
    77337733/* Line 1806 of yacc.c  */
    7734 #line 1940 "parser.yy"
     7734#line 1939 "parser.yy"
    77357735    {
    77367736                        typedefTable.leaveTrait();
    … …  
    77437743
    77447744/* Line 1806 of yacc.c  */
    7745 #line 1950 "parser.yy"
     7745#line 1949 "parser.yy"
    77467746    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    77477747    break;
    … …  
    77507750
    77517751/* Line 1806 of yacc.c  */
    7752 #line 1960 "parser.yy"
     7752#line 1959 "parser.yy"
    77537753    {
    77547754                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    77607760
    77617761/* Line 1806 of yacc.c  */
    7762 #line 1965 "parser.yy"
     7762#line 1964 "parser.yy"
    77637763    {
    77647764                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    77707770
    77717771/* Line 1806 of yacc.c  */
    7772 #line 1970 "parser.yy"
     7772#line 1969 "parser.yy"
    77737773    {
    77747774                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    77807780
    77817781/* Line 1806 of yacc.c  */
    7782 #line 1978 "parser.yy"
     7782#line 1977 "parser.yy"
    77837783    {
    77847784                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    77907790
    77917791/* Line 1806 of yacc.c  */
    7792 #line 1983 "parser.yy"
     7792#line 1982 "parser.yy"
    77937793    {
    77947794                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    78007800
    78017801/* Line 1806 of yacc.c  */
    7802 #line 1993 "parser.yy"
     7802#line 1992 "parser.yy"
    78037803    {}
    78047804    break;
    … …  
    78077807
    78087808/* Line 1806 of yacc.c  */
    7809 #line 1995 "parser.yy"
     7809#line 1994 "parser.yy"
    78107810    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
    78117811    break;
    … …  
    78147814
    78157815/* Line 1806 of yacc.c  */
    7816 #line 2001 "parser.yy"
     7816#line 2000 "parser.yy"
    78177817    { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    78187818    break;
    … …  
    78217821
    78227822/* Line 1806 of yacc.c  */
    7823 #line 2006 "parser.yy"
     7823#line 2005 "parser.yy"
    78247824    { (yyval.decl) = 0; }
    78257825    break;
    … …  
    78287828
    78297829/* Line 1806 of yacc.c  */
    7830 #line 2014 "parser.yy"
     7830#line 2013 "parser.yy"
    78317831    {}
    78327832    break;
    … …  
    78357835
    78367836/* Line 1806 of yacc.c  */
    7837 #line 2016 "parser.yy"
     7837#line 2015 "parser.yy"
    78387838    {
    78397839                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
    … …  
    78457845
    78467846/* Line 1806 of yacc.c  */
    7847 #line 2021 "parser.yy"
     7847#line 2020 "parser.yy"
    78487848    {
    78497849                        linkage = linkageStack.top();
    … …  
    78567856
    78577857/* Line 1806 of yacc.c  */
    7858 #line 2027 "parser.yy"
     7858#line 2026 "parser.yy"
    78597859    {   // mark all fields in list
    78607860                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    78677867
    78687868/* Line 1806 of yacc.c  */
    7869 #line 2042 "parser.yy"
     7869#line 2041 "parser.yy"
    78707870    {
    78717871                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78787878
    78797879/* Line 1806 of yacc.c  */
    7880 #line 2048 "parser.yy"
     7880#line 2047 "parser.yy"
    78817881    {
    78827882                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78897889
    78907890/* Line 1806 of yacc.c  */
    7891 #line 2057 "parser.yy"
     7891#line 2056 "parser.yy"
    78927892    {
    78937893                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79007900
    79017901/* Line 1806 of yacc.c  */
    7902 #line 2063 "parser.yy"
     7902#line 2062 "parser.yy"
    79037903    {
    79047904                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79117911
    79127912/* Line 1806 of yacc.c  */
    7913 #line 2069 "parser.yy"
     7913#line 2068 "parser.yy"
    79147914    {
    79157915                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79227922
    79237923/* Line 1806 of yacc.c  */
    7924 #line 2075 "parser.yy"
     7924#line 2074 "parser.yy"
    79257925    {
    79267926                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79337933
    79347934/* Line 1806 of yacc.c  */
    7935 #line 2081 "parser.yy"
     7935#line 2080 "parser.yy"
    79367936    {
    79377937                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79447944
    79457945/* Line 1806 of yacc.c  */
    7946 #line 2089 "parser.yy"
     7946#line 2088 "parser.yy"
    79477947    {
    79487948                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79557955
    79567956/* Line 1806 of yacc.c  */
    7957 #line 2095 "parser.yy"
     7957#line 2094 "parser.yy"
    79587958    {
    79597959                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79667966
    79677967/* Line 1806 of yacc.c  */
    7968 #line 2103 "parser.yy"
     7968#line 2102 "parser.yy"
    79697969    {
    79707970                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79777977
    79787978/* Line 1806 of yacc.c  */
    7979 #line 2109 "parser.yy"
     7979#line 2108 "parser.yy"
    79807980    {
    79817981                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79887988
    79897989/* Line 1806 of yacc.c  */
    7990 #line 2124 "parser.yy"
     7990#line 2123 "parser.yy"
    79917991    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    79927992    break;
    … …  
    79957995
    79967996/* Line 1806 of yacc.c  */
    7997 #line 2129 "parser.yy"
     7997#line 2128 "parser.yy"
    79987998    { delete (yyvsp[(3) - (5)].str); }
    79997999    break;
    … …  
    80028002
    80038003/* Line 1806 of yacc.c  */
    8004 #line 2134 "parser.yy"
     8004#line 2133 "parser.yy"
    80058005    { (yyval.decl) = 0; }
    80068006    break;
    … …  
    80098009
    80108010/* Line 1806 of yacc.c  */
    8011 #line 2141 "parser.yy"
     8011#line 2140 "parser.yy"
    80128012    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    80138013    break;
    … …  
    80168016
    80178017/* Line 1806 of yacc.c  */
    8018 #line 2147 "parser.yy"
     8018#line 2146 "parser.yy"
    80198019    { (yyval.decl) = 0; }
    80208020    break;
    … …  
    80238023
    80248024/* Line 1806 of yacc.c  */
    8025 #line 2158 "parser.yy"
     8025#line 2157 "parser.yy"
    80268026    { delete (yyvsp[(3) - (4)].en); }
    80278027    break;
    … …  
    80308030
    80318031/* Line 1806 of yacc.c  */
     8032#line 2161 "parser.yy"
     8033    { delete (yyvsp[(1) - (1)].tok); }
     8034    break;
     8035
     8036  case 560:
     8037
     8038/* Line 1806 of yacc.c  */
    80328039#line 2162 "parser.yy"
    8033     { delete (yyvsp[(1) - (1)].tok); }
    8034     break;
    8035 
    8036   case 560:
     8040    { delete (yyvsp[(1) - (1)].decl); }
     8041    break;
     8042
     8043  case 561:
    80378044
    80388045/* Line 1806 of yacc.c  */
    … …  
    80418048    break;
    80428049
    8043   case 561:
     8050  case 562:
    80448051
    80458052/* Line 1806 of yacc.c  */
    … …  
    80488055    break;
    80498056
    8050   case 562:
    8051 
    8052 /* Line 1806 of yacc.c  */
    8053 #line 2165 "parser.yy"
    8054     { delete (yyvsp[(1) - (1)].decl); }
    8055     break;
    8056 
    80578057  case 563:
    80588058
    80598059/* Line 1806 of yacc.c  */
    8060 #line 2200 "parser.yy"
     8060#line 2199 "parser.yy"
    80618061    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80628062    break;
    … …  
    80658065
    80668066/* Line 1806 of yacc.c  */
    8067 #line 2203 "parser.yy"
     8067#line 2202 "parser.yy"
    80688068    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80698069    break;
    … …  
    80728072
    80738073/* Line 1806 of yacc.c  */
    8074 #line 2205 "parser.yy"
     8074#line 2204 "parser.yy"
    80758075    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80768076    break;
    … …  
    80798079
    80808080/* Line 1806 of yacc.c  */
    8081 #line 2210 "parser.yy"
     8081#line 2209 "parser.yy"
    80828082    {
    80838083                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    80898089
    80908090/* Line 1806 of yacc.c  */
    8091 #line 2215 "parser.yy"
     8091#line 2214 "parser.yy"
    80928092    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80938093    break;
    … …  
    80968096
    80978097/* Line 1806 of yacc.c  */
    8098 #line 2220 "parser.yy"
     8098#line 2219 "parser.yy"
    80998099    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81008100    break;
    … …  
    81038103
    81048104/* Line 1806 of yacc.c  */
    8105 #line 2222 "parser.yy"
     8105#line 2221 "parser.yy"
    81068106    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81078107    break;
    … …  
    81108110
    81118111/* Line 1806 of yacc.c  */
    8112 #line 2224 "parser.yy"
     8112#line 2223 "parser.yy"
    81138113    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81148114    break;
    … …  
    81178117
    81188118/* Line 1806 of yacc.c  */
    8119 #line 2229 "parser.yy"
     8119#line 2228 "parser.yy"
    81208120    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    81218121    break;
    … …  
    81248124
    81258125/* Line 1806 of yacc.c  */
    8126 #line 2231 "parser.yy"
     8126#line 2230 "parser.yy"
    81278127    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81288128    break;
    … …  
    81318131
    81328132/* Line 1806 of yacc.c  */
    8133 #line 2233 "parser.yy"
     8133#line 2232 "parser.yy"
    81348134    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81358135    break;
    … …  
    81388138
    81398139/* Line 1806 of yacc.c  */
    8140 #line 2235 "parser.yy"
     8140#line 2234 "parser.yy"
    81418141    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81428142    break;
    … …  
    81458145
    81468146/* Line 1806 of yacc.c  */
    8147 #line 2240 "parser.yy"
     8147#line 2239 "parser.yy"
    81488148    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81498149    break;
    … …  
    81528152
    81538153/* Line 1806 of yacc.c  */
    8154 #line 2242 "parser.yy"
     8154#line 2241 "parser.yy"
    81558155    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81568156    break;
    … …  
    81598159
    81608160/* Line 1806 of yacc.c  */
    8161 #line 2251 "parser.yy"
     8161#line 2250 "parser.yy"
    81628162    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81638163    break;
    … …  
    81668166
    81678167/* Line 1806 of yacc.c  */
    8168 #line 2254 "parser.yy"
     8168#line 2253 "parser.yy"
    81698169    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81708170    break;
    … …  
    81738173
    81748174/* Line 1806 of yacc.c  */
    8175 #line 2259 "parser.yy"
     8175#line 2258 "parser.yy"
    81768176    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    81778177    break;
    … …  
    81808180
    81818181/* Line 1806 of yacc.c  */
    8182 #line 2261 "parser.yy"
     8182#line 2260 "parser.yy"
    81838183    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81848184    break;
    … …  
    81878187
    81888188/* Line 1806 of yacc.c  */
    8189 #line 2263 "parser.yy"
     8189#line 2262 "parser.yy"
    81908190    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81918191    break;
    … …  
    81948194
    81958195/* Line 1806 of yacc.c  */
    8196 #line 2268 "parser.yy"
     8196#line 2267 "parser.yy"
    81978197    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81988198    break;
    … …  
    82018201
    82028202/* Line 1806 of yacc.c  */
    8203 #line 2270 "parser.yy"
     8203#line 2269 "parser.yy"
    82048204    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82058205    break;
    … …  
    82088208
    82098209/* Line 1806 of yacc.c  */
    8210 #line 2272 "parser.yy"
     8210#line 2271 "parser.yy"
    82118211    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82128212    break;
    … …  
    82158215
    82168216/* Line 1806 of yacc.c  */
    8217 #line 2277 "parser.yy"
     8217#line 2276 "parser.yy"
    82188218    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82198219    break;
    … …  
    82228222
    82238223/* Line 1806 of yacc.c  */
    8224 #line 2279 "parser.yy"
     8224#line 2278 "parser.yy"
    82258225    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82268226    break;
    … …  
    82298229
    82308230/* Line 1806 of yacc.c  */
    8231 #line 2281 "parser.yy"
     8231#line 2280 "parser.yy"
    82328232    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82338233    break;
    … …  
    82368236
    82378237/* Line 1806 of yacc.c  */
    8238 #line 2296 "parser.yy"
     8238#line 2295 "parser.yy"
    82398239    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    82408240    break;
    … …  
    82438243
    82448244/* Line 1806 of yacc.c  */
    8245 #line 2298 "parser.yy"
     8245#line 2297 "parser.yy"
    82468246    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    82478247    break;
    … …  
    82508250
    82518251/* Line 1806 of yacc.c  */
    8252 #line 2300 "parser.yy"
     8252#line 2299 "parser.yy"
    82538253    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82548254    break;
    … …  
    82578257
    82588258/* Line 1806 of yacc.c  */
    8259 #line 2305 "parser.yy"
     8259#line 2304 "parser.yy"
    82608260    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    82618261    break;
    … …  
    82648264
    82658265/* Line 1806 of yacc.c  */
    8266 #line 2307 "parser.yy"
     8266#line 2306 "parser.yy"
    82678267    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82688268    break;
    … …  
    82718271
    82728272/* Line 1806 of yacc.c  */
    8273 #line 2309 "parser.yy"
     8273#line 2308 "parser.yy"
    82748274    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82758275    break;
    … …  
    82788278
    82798279/* Line 1806 of yacc.c  */
    8280 #line 2314 "parser.yy"
     8280#line 2313 "parser.yy"
    82818281    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82828282    break;
    … …  
    82858285
    82868286/* Line 1806 of yacc.c  */
    8287 #line 2316 "parser.yy"
     8287#line 2315 "parser.yy"
    82888288    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82898289    break;
    … …  
    82928292
    82938293/* Line 1806 of yacc.c  */
    8294 #line 2318 "parser.yy"
     8294#line 2317 "parser.yy"
    82958295    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82968296    break;
    … …  
    82998299
    83008300/* Line 1806 of yacc.c  */
    8301 #line 2333 "parser.yy"
     8301#line 2332 "parser.yy"
    83028302    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83038303    break;
    … …  
    83068306
    83078307/* Line 1806 of yacc.c  */
    8308 #line 2336 "parser.yy"
     8308#line 2335 "parser.yy"
    83098309    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83108310    break;
    … …  
    83138313
    83148314/* Line 1806 of yacc.c  */
    8315 #line 2338 "parser.yy"
     8315#line 2337 "parser.yy"
    83168316    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83178317    break;
    … …  
    83208320
    83218321/* Line 1806 of yacc.c  */
    8322 #line 2344 "parser.yy"
     8322#line 2343 "parser.yy"
    83238323    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83248324    break;
    … …  
    83278327
    83288328/* Line 1806 of yacc.c  */
    8329 #line 2349 "parser.yy"
     8329#line 2348 "parser.yy"
    83308330    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83318331    break;
    … …  
    83348334
    83358335/* Line 1806 of yacc.c  */
    8336 #line 2351 "parser.yy"
     8336#line 2350 "parser.yy"
    83378337    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83388338    break;
    … …  
    83418341
    83428342/* Line 1806 of yacc.c  */
    8343 #line 2353 "parser.yy"
     8343#line 2352 "parser.yy"
    83448344    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83458345    break;
    … …  
    83488348
    83498349/* Line 1806 of yacc.c  */
    8350 #line 2358 "parser.yy"
     8350#line 2357 "parser.yy"
    83518351    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83528352    break;
    … …  
    83558355
    83568356/* Line 1806 of yacc.c  */
    8357 #line 2360 "parser.yy"
     8357#line 2359 "parser.yy"
    83588358    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83598359    break;
    … …  
    83628362
    83638363/* Line 1806 of yacc.c  */
    8364 #line 2362 "parser.yy"
     8364#line 2361 "parser.yy"
    83658365    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83668366    break;
    … …  
    83698369
    83708370/* Line 1806 of yacc.c  */
    8371 #line 2364 "parser.yy"
     8371#line 2363 "parser.yy"
    83728372    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83738373    break;
    … …  
    83768376
    83778377/* Line 1806 of yacc.c  */
    8378 #line 2369 "parser.yy"
     8378#line 2368 "parser.yy"
    83798379    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83808380    break;
    … …  
    83838383
    83848384/* Line 1806 of yacc.c  */
    8385 #line 2371 "parser.yy"
     8385#line 2370 "parser.yy"
    83868386    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83878387    break;
    … …  
    83908390
    83918391/* Line 1806 of yacc.c  */
    8392 #line 2373 "parser.yy"
     8392#line 2372 "parser.yy"
    83938393    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83948394    break;
    … …  
    83978397
    83988398/* Line 1806 of yacc.c  */
    8399 #line 2383 "parser.yy"
     8399#line 2382 "parser.yy"
    84008400    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84018401    break;
    … …  
    84048404
    84058405/* Line 1806 of yacc.c  */
    8406 #line 2386 "parser.yy"
     8406#line 2385 "parser.yy"
    84078407    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84088408    break;
    … …  
    84118411
    84128412/* Line 1806 of yacc.c  */
    8413 #line 2388 "parser.yy"
     8413#line 2387 "parser.yy"
    84148414    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84158415    break;
    … …  
    84188418
    84198419/* Line 1806 of yacc.c  */
    8420 #line 2393 "parser.yy"
     8420#line 2392 "parser.yy"
    84218421    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84228422    break;
    … …  
    84258425
    84268426/* Line 1806 of yacc.c  */
    8427 #line 2395 "parser.yy"
     8427#line 2394 "parser.yy"
    84288428    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84298429    break;
    … …  
    84328432
    84338433/* Line 1806 of yacc.c  */
    8434 #line 2397 "parser.yy"
     8434#line 2396 "parser.yy"
    84358435    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84368436    break;
    … …  
    84398439
    84408440/* Line 1806 of yacc.c  */
    8441 #line 2402 "parser.yy"
     8441#line 2401 "parser.yy"
    84428442    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    84438443    break;
    … …  
    84468446
    84478447/* Line 1806 of yacc.c  */
    8448 #line 2404 "parser.yy"
     8448#line 2403 "parser.yy"
    84498449    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84508450    break;
    … …  
    84538453
    84548454/* Line 1806 of yacc.c  */
    8455 #line 2406 "parser.yy"
     8455#line 2405 "parser.yy"
    84568456    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84578457    break;
    … …  
    84608460
    84618461/* Line 1806 of yacc.c  */
    8462 #line 2408 "parser.yy"
     8462#line 2407 "parser.yy"
    84638463    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84648464    break;
    … …  
    84678467
    84688468/* Line 1806 of yacc.c  */
    8469 #line 2413 "parser.yy"
     8469#line 2412 "parser.yy"
    84708470    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    84718471    break;
    … …  
    84748474
    84758475/* Line 1806 of yacc.c  */
    8476 #line 2415 "parser.yy"
     8476#line 2414 "parser.yy"
    84778477    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    84788478    break;
    … …  
    84818481
    84828482/* Line 1806 of yacc.c  */
    8483 #line 2417 "parser.yy"
     8483#line 2416 "parser.yy"
    84848484    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84858485    break;
    … …  
    84888488
    84898489/* Line 1806 of yacc.c  */
    8490 #line 2448 "parser.yy"
     8490#line 2447 "parser.yy"
    84918491    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84928492    break;
    … …  
    84958495
    84968496/* Line 1806 of yacc.c  */
    8497 #line 2451 "parser.yy"
     8497#line 2450 "parser.yy"
    84988498    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84998499    break;
    … …  
    85028502
    85038503/* Line 1806 of yacc.c  */
    8504 #line 2453 "parser.yy"
     8504#line 2452 "parser.yy"
    85058505    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85068506    break;
    … …  
    85098509
    85108510/* Line 1806 of yacc.c  */
    8511 #line 2458 "parser.yy"
     8511#line 2457 "parser.yy"
    85128512    {
    85138513                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    85198519
    85208520/* Line 1806 of yacc.c  */
    8521 #line 2463 "parser.yy"
     8521#line 2462 "parser.yy"
    85228522    {
    85238523                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    85298529
    85308530/* Line 1806 of yacc.c  */
    8531 #line 2471 "parser.yy"
     8531#line 2470 "parser.yy"
    85328532    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85338533    break;
    … …  
    85368536
    85378537/* Line 1806 of yacc.c  */
    8538 #line 2473 "parser.yy"
     8538#line 2472 "parser.yy"
    85398539    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85408540    break;
    … …  
    85438543
    85448544/* Line 1806 of yacc.c  */
    8545 #line 2475 "parser.yy"
     8545#line 2474 "parser.yy"
    85468546    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85478547    break;
    … …  
    85508550
    85518551/* Line 1806 of yacc.c  */
    8552 #line 2480 "parser.yy"
     8552#line 2479 "parser.yy"
    85538553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85548554    break;
    … …  
    85578557
    85588558/* Line 1806 of yacc.c  */
    8559 #line 2482 "parser.yy"
     8559#line 2481 "parser.yy"
    85608560    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85618561    break;
    … …  
    85648564
    85658565/* Line 1806 of yacc.c  */
    8566 #line 2487 "parser.yy"
     8566#line 2486 "parser.yy"
    85678567    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85688568    break;
    … …  
    85718571
    85728572/* Line 1806 of yacc.c  */
    8573 #line 2489 "parser.yy"
     8573#line 2488 "parser.yy"
    85748574    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85758575    break;
    … …  
    85788578
    85798579/* Line 1806 of yacc.c  */
    8580 #line 2504 "parser.yy"
     8580#line 2503 "parser.yy"
    85818581    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85828582    break;
    … …  
    85858585
    85868586/* Line 1806 of yacc.c  */
    8587 #line 2506 "parser.yy"
     8587#line 2505 "parser.yy"
    85888588    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85898589    break;
    … …  
    85928592
    85938593/* Line 1806 of yacc.c  */
    8594 #line 2511 "parser.yy"
     8594#line 2510 "parser.yy"
    85958595    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85968596    break;
    … …  
    85998599
    86008600/* Line 1806 of yacc.c  */
    8601 #line 2513 "parser.yy"
     8601#line 2512 "parser.yy"
    86028602    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    86038603    break;
    … …  
    86068606
    86078607/* Line 1806 of yacc.c  */
    8608 #line 2515 "parser.yy"
     8608#line 2514 "parser.yy"
    86098609    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86108610    break;
    … …  
    86138613
    86148614/* Line 1806 of yacc.c  */
    8615 #line 2517 "parser.yy"
     8615#line 2516 "parser.yy"
    86168616    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86178617    break;
    … …  
    86208620
    86218621/* Line 1806 of yacc.c  */
    8622 #line 2519 "parser.yy"
     8622#line 2518 "parser.yy"
    86238623    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86248624    break;
    … …  
    86278627
    86288628/* Line 1806 of yacc.c  */
    8629 #line 2525 "parser.yy"
     8629#line 2524 "parser.yy"
    86308630    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86318631    break;
    … …  
    86348634
    86358635/* Line 1806 of yacc.c  */
    8636 #line 2527 "parser.yy"
     8636#line 2526 "parser.yy"
    86378637    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86388638    break;
    … …  
    86418641
    86428642/* Line 1806 of yacc.c  */
    8643 #line 2529 "parser.yy"
     8643#line 2528 "parser.yy"
    86448644    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86458645    break;
    … …  
    86488648
    86498649/* Line 1806 of yacc.c  */
    8650 #line 2534 "parser.yy"
     8650#line 2533 "parser.yy"
    86518651    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
    86528652    break;
    … …  
    86558655
    86568656/* Line 1806 of yacc.c  */
    8657 #line 2536 "parser.yy"
     8657#line 2535 "parser.yy"
    86588658    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86598659    break;
    … …  
    86628662
    86638663/* Line 1806 of yacc.c  */
    8664 #line 2538 "parser.yy"
     8664#line 2537 "parser.yy"
    86658665    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86668666    break;
    … …  
    86698669
    86708670/* Line 1806 of yacc.c  */
    8671 #line 2544 "parser.yy"
     8671#line 2543 "parser.yy"
    86728672    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86738673    break;
    … …  
    86768676
    86778677/* Line 1806 of yacc.c  */
    8678 #line 2546 "parser.yy"
     8678#line 2545 "parser.yy"
    86798679    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    86808680    break;
    … …  
    86838683
    86848684/* Line 1806 of yacc.c  */
    8685 #line 2552 "parser.yy"
     8685#line 2551 "parser.yy"
    86868686    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    86878687    break;
    … …  
    86908690
    86918691/* Line 1806 of yacc.c  */
    8692 #line 2554 "parser.yy"
     8692#line 2553 "parser.yy"
    86938693    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    86948694    break;
    … …  
    86978697
    86988698/* Line 1806 of yacc.c  */
    8699 #line 2556 "parser.yy"
     8699#line 2555 "parser.yy"
    87008700    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    87018701    break;
    … …  
    87048704
    87058705/* Line 1806 of yacc.c  */
    8706 #line 2558 "parser.yy"
     8706#line 2557 "parser.yy"
    87078707    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    87088708    break;
    … …  
    87118711
    87128712/* Line 1806 of yacc.c  */
    8713 #line 2573 "parser.yy"
     8713#line 2572 "parser.yy"
    87148714    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87158715    break;
    … …  
    87188718
    87198719/* Line 1806 of yacc.c  */
    8720 #line 2575 "parser.yy"
     8720#line 2574 "parser.yy"
    87218721    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87228722    break;
    … …  
    87258725
    87268726/* Line 1806 of yacc.c  */
    8727 #line 2580 "parser.yy"
     8727#line 2579 "parser.yy"
    87288728    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    87298729    break;
    … …  
    87328732
    87338733/* Line 1806 of yacc.c  */
    8734 #line 2582 "parser.yy"
     8734#line 2581 "parser.yy"
    87358735    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    87368736    break;
    … …  
    87398739
    87408740/* Line 1806 of yacc.c  */
    8741 #line 2584 "parser.yy"
     8741#line 2583 "parser.yy"
    87428742    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87438743    break;
    … …  
    87468746
    87478747/* Line 1806 of yacc.c  */
    8748 #line 2586 "parser.yy"
     8748#line 2585 "parser.yy"
    87498749    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87508750    break;
    … …  
    87538753
    87548754/* Line 1806 of yacc.c  */
    8755 #line 2588 "parser.yy"
     8755#line 2587 "parser.yy"
    87568756    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87578757    break;
    … …  
    87608760
    87618761/* Line 1806 of yacc.c  */
    8762 #line 2594 "parser.yy"
     8762#line 2593 "parser.yy"
    87638763    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87648764    break;
    … …  
    87678767
    87688768/* Line 1806 of yacc.c  */
    8769 #line 2596 "parser.yy"
     8769#line 2595 "parser.yy"
    87708770    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87718771    break;
    … …  
    87748774
    87758775/* Line 1806 of yacc.c  */
    8776 #line 2598 "parser.yy"
     8776#line 2597 "parser.yy"
    87778777    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87788778    break;
    … …  
    87818781
    87828782/* Line 1806 of yacc.c  */
    8783 #line 2603 "parser.yy"
     8783#line 2602 "parser.yy"
    87848784    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
    87858785    break;
    … …  
    87888788
    87898789/* Line 1806 of yacc.c  */
    8790 #line 2605 "parser.yy"
     8790#line 2604 "parser.yy"
    87918791    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87928792    break;
    … …  
    87958795
    87968796/* Line 1806 of yacc.c  */
    8797 #line 2607 "parser.yy"
     8797#line 2606 "parser.yy"
    87988798    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87998799    break;
    … …  
    88028802
    88038803/* Line 1806 of yacc.c  */
    8804 #line 2614 "parser.yy"
     8804#line 2613 "parser.yy"
    88058805    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    88068806    break;
    … …  
    88098809
    88108810/* Line 1806 of yacc.c  */
    8811 #line 2625 "parser.yy"
     8811#line 2624 "parser.yy"
    88128812    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    88138813    break;
    … …  
    88168816
    88178817/* Line 1806 of yacc.c  */
    8818 #line 2628 "parser.yy"
     8818#line 2627 "parser.yy"
    88198819    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    88208820    break;
    … …  
    88238823
    88248824/* Line 1806 of yacc.c  */
    8825 #line 2630 "parser.yy"
     8825#line 2629 "parser.yy"
    88268826    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    88278827    break;
    … …  
    88308830
    88318831/* Line 1806 of yacc.c  */
    8832 #line 2633 "parser.yy"
     8832#line 2632 "parser.yy"
    88338833    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    88348834    break;
    … …  
    88378837
    88388838/* Line 1806 of yacc.c  */
    8839 #line 2635 "parser.yy"
     8839#line 2634 "parser.yy"
    88408840    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    88418841    break;
    … …  
    88448844
    88458845/* Line 1806 of yacc.c  */
    8846 #line 2637 "parser.yy"
     8846#line 2636 "parser.yy"
    88478847    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    88488848    break;
    … …  
    88518851
    88528852/* Line 1806 of yacc.c  */
    8853 #line 2651 "parser.yy"
     8853#line 2650 "parser.yy"
    88548854    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88558855    break;
    … …  
    88588858
    88598859/* Line 1806 of yacc.c  */
    8860 #line 2653 "parser.yy"
     8860#line 2652 "parser.yy"
    88618861    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88628862    break;
    … …  
    88658865
    88668866/* Line 1806 of yacc.c  */
    8867 #line 2658 "parser.yy"
     8867#line 2657 "parser.yy"
    88688868    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88698869    break;
    … …  
    88728872
    88738873/* Line 1806 of yacc.c  */
    8874 #line 2660 "parser.yy"
     8874#line 2659 "parser.yy"
    88758875    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88768876    break;
    … …  
    88798879
    88808880/* Line 1806 of yacc.c  */
    8881 #line 2662 "parser.yy"
     8881#line 2661 "parser.yy"
    88828882    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88838883    break;
    … …  
    88868886
    88878887/* Line 1806 of yacc.c  */
    8888 #line 2664 "parser.yy"
     8888#line 2663 "parser.yy"
    88898889    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88908890    break;
    … …  
    88938893
    88948894/* Line 1806 of yacc.c  */
    8895 #line 2666 "parser.yy"
     8895#line 2665 "parser.yy"
    88968896    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88978897    break;
    … …  
    89008900
    89018901/* Line 1806 of yacc.c  */
    8902 #line 2672 "parser.yy"
     8902#line 2671 "parser.yy"
    89038903    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89048904    break;
    … …  
    89078907
    89088908/* Line 1806 of yacc.c  */
    8909 #line 2674 "parser.yy"
     8909#line 2673 "parser.yy"
    89108910    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89118911    break;
    … …  
    89148914
    89158915/* Line 1806 of yacc.c  */
    8916 #line 2676 "parser.yy"
     8916#line 2675 "parser.yy"
    89178917    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89188918    break;
    … …  
    89218921
    89228922/* Line 1806 of yacc.c  */
    8923 #line 2681 "parser.yy"
     8923#line 2680 "parser.yy"
    89248924    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    89258925    break;
    … …  
    89288928
    89298929/* Line 1806 of yacc.c  */
    8930 #line 2683 "parser.yy"
     8930#line 2682 "parser.yy"
    89318931    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89328932    break;
    … …  
    89358935
    89368936/* Line 1806 of yacc.c  */
    8937 #line 2693 "parser.yy"
     8937#line 2692 "parser.yy"
    89388938    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    89398939    break;
    … …  
    89428942
    89438943/* Line 1806 of yacc.c  */
    8944 #line 2703 "parser.yy"
     8944#line 2702 "parser.yy"
    89458945    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89468946    break;
    … …  
    89498949
    89508950/* Line 1806 of yacc.c  */
    8951 #line 2705 "parser.yy"
     8951#line 2704 "parser.yy"
    89528952    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89538953    break;
    … …  
    89568956
    89578957/* Line 1806 of yacc.c  */
    8958 #line 2707 "parser.yy"
     8958#line 2706 "parser.yy"
    89598959    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89608960    break;
    … …  
    89638963
    89648964/* Line 1806 of yacc.c  */
    8965 #line 2709 "parser.yy"
     8965#line 2708 "parser.yy"
    89668966    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89678967    break;
    … …  
    89708970
    89718971/* Line 1806 of yacc.c  */
    8972 #line 2711 "parser.yy"
     8972#line 2710 "parser.yy"
    89738973    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89748974    break;
    … …  
    89778977
    89788978/* Line 1806 of yacc.c  */
    8979 #line 2713 "parser.yy"
     8979#line 2712 "parser.yy"
    89808980    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89818981    break;
    … …  
    89848984
    89858985/* Line 1806 of yacc.c  */
    8986 #line 2720 "parser.yy"
     8986#line 2719 "parser.yy"
    89878987    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89888988    break;
    … …  
    89918991
    89928992/* Line 1806 of yacc.c  */
    8993 #line 2722 "parser.yy"
     8993#line 2721 "parser.yy"
    89948994    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89958995    break;
    … …  
    89988998
    89998999/* Line 1806 of yacc.c  */
    9000 #line 2724 "parser.yy"
     9000#line 2723 "parser.yy"
    90019001    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    90029002    break;
    … …  
    90059005
    90069006/* Line 1806 of yacc.c  */
    9007 #line 2726 "parser.yy"
     9007#line 2725 "parser.yy"
    90089008    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    90099009    break;
    … …  
    90129012
    90139013/* Line 1806 of yacc.c  */
    9014 #line 2728 "parser.yy"
     9014#line 2727 "parser.yy"
    90159015    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90169016    break;
    … …  
    90199019
    90209020/* Line 1806 of yacc.c  */
     9021#line 2729 "parser.yy"
     9022    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9023    break;
     9024
     9025  case 722:
     9026
     9027/* Line 1806 of yacc.c  */
    90219028#line 2731 "parser.yy"
    9022     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9023     break;
    9024 
    9025   case 722:
     9029    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9030    break;
     9031
     9032  case 723:
    90269033
    90279034/* Line 1806 of yacc.c  */
    90289035#line 2733 "parser.yy"
     9036    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9037    break;
     9038
     9039  case 724:
     9040
     9041/* Line 1806 of yacc.c  */
     9042#line 2735 "parser.yy"
     9043    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     9044    break;
     9045
     9046  case 725:
     9047
     9048/* Line 1806 of yacc.c  */
     9049#line 2737 "parser.yy"
    90299050    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90309051    break;
    90319052
    9032   case 723:
    9033 
    9034 /* Line 1806 of yacc.c  */
    9035 #line 2735 "parser.yy"
    9036     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9037     break;
    9038 
    9039   case 724:
    9040 
    9041 /* Line 1806 of yacc.c  */
    9042 #line 2737 "parser.yy"
    9043     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9044     break;
    9045 
    9046   case 725:
    9047 
    9048 /* Line 1806 of yacc.c  */
    9049 #line 2739 "parser.yy"
     9053  case 726:
     9054
     9055/* Line 1806 of yacc.c  */
     9056#line 2742 "parser.yy"
     9057    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     9058    break;
     9059
     9060  case 727:
     9061
     9062/* Line 1806 of yacc.c  */
     9063#line 2744 "parser.yy"
     9064    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     9065    break;
     9066
     9067  case 728:
     9068
     9069/* Line 1806 of yacc.c  */
     9070#line 2749 "parser.yy"
     9071    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
     9072    break;
     9073
     9074  case 729:
     9075
     9076/* Line 1806 of yacc.c  */
     9077#line 2751 "parser.yy"
     9078    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
     9079    break;
     9080
     9081  case 731:
     9082
     9083/* Line 1806 of yacc.c  */
     9084#line 2778 "parser.yy"
     9085    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     9086    break;
     9087
     9088  case 735:
     9089
     9090/* Line 1806 of yacc.c  */
     9091#line 2789 "parser.yy"
     9092    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9093    break;
     9094
     9095  case 736:
     9096
     9097/* Line 1806 of yacc.c  */
     9098#line 2791 "parser.yy"
     9099    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9100    break;
     9101
     9102  case 737:
     9103
     9104/* Line 1806 of yacc.c  */
     9105#line 2793 "parser.yy"
     9106    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9107    break;
     9108
     9109  case 738:
     9110
     9111/* Line 1806 of yacc.c  */
     9112#line 2795 "parser.yy"
     9113    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9114    break;
     9115
     9116  case 739:
     9117
     9118/* Line 1806 of yacc.c  */
     9119#line 2797 "parser.yy"
     9120    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9121    break;
     9122
     9123  case 740:
     9124
     9125/* Line 1806 of yacc.c  */
     9126#line 2799 "parser.yy"
     9127    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9128    break;
     9129
     9130  case 741:
     9131
     9132/* Line 1806 of yacc.c  */
     9133#line 2806 "parser.yy"
     9134    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     9135    break;
     9136
     9137  case 742:
     9138
     9139/* Line 1806 of yacc.c  */
     9140#line 2808 "parser.yy"
     9141    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     9142    break;
     9143
     9144  case 743:
     9145
     9146/* Line 1806 of yacc.c  */
     9147#line 2810 "parser.yy"
    90509148    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90519149    break;
    90529150
    9053   case 726:
    9054 
    9055 /* Line 1806 of yacc.c  */
    9056 #line 2744 "parser.yy"
    9057     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    9058     break;
    9059 
    9060   case 727:
    9061 
    9062 /* Line 1806 of yacc.c  */
    9063 #line 2746 "parser.yy"
    9064     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    9065     break;
    9066 
    9067   case 728:
    9068 
    9069 /* Line 1806 of yacc.c  */
    9070 #line 2751 "parser.yy"
    9071     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    9072     break;
    9073 
    9074   case 729:
    9075 
    9076 /* Line 1806 of yacc.c  */
    9077 #line 2753 "parser.yy"
    9078     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    9079     break;
    9080 
    9081   case 731:
    9082 
    9083 /* Line 1806 of yacc.c  */
    9084 #line 2780 "parser.yy"
    9085     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    9086     break;
    9087 
    9088   case 735:
    9089 
    9090 /* Line 1806 of yacc.c  */
    9091 #line 2791 "parser.yy"
    9092     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9093     break;
    9094 
    9095   case 736:
    9096 
    9097 /* Line 1806 of yacc.c  */
    9098 #line 2793 "parser.yy"
    9099     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9100     break;
    9101 
    9102   case 737:
    9103 
    9104 /* Line 1806 of yacc.c  */
    9105 #line 2795 "parser.yy"
    9106     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9107     break;
    9108 
    9109   case 738:
    9110 
    9111 /* Line 1806 of yacc.c  */
    9112 #line 2797 "parser.yy"
    9113     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9114     break;
    9115 
    9116   case 739:
    9117 
    9118 /* Line 1806 of yacc.c  */
    9119 #line 2799 "parser.yy"
    9120     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9121     break;
    9122 
    9123   case 740:
    9124 
    9125 /* Line 1806 of yacc.c  */
    9126 #line 2801 "parser.yy"
    9127     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9128     break;
    9129 
    9130   case 741:
    9131 
    9132 /* Line 1806 of yacc.c  */
    9133 #line 2808 "parser.yy"
     9151  case 744:
     9152
     9153/* Line 1806 of yacc.c  */
     9154#line 2812 "parser.yy"
    91349155    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    91359156    break;
    91369157
    9137   case 742:
    9138 
    9139 /* Line 1806 of yacc.c  */
    9140 #line 2810 "parser.yy"
     9158  case 745:
     9159
     9160/* Line 1806 of yacc.c  */
     9161#line 2814 "parser.yy"
    91419162    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    91429163    break;
    91439164
    9144   case 743:
    9145 
    9146 /* Line 1806 of yacc.c  */
    9147 #line 2812 "parser.yy"
     9165  case 746:
     9166
     9167/* Line 1806 of yacc.c  */
     9168#line 2816 "parser.yy"
    91489169    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    91499170    break;
    91509171
    9151   case 744:
    9152 
    9153 /* Line 1806 of yacc.c  */
    9154 #line 2814 "parser.yy"
    9155     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    9156     break;
    9157 
    9158   case 745:
    9159 
    9160 /* Line 1806 of yacc.c  */
    9161 #line 2816 "parser.yy"
    9162     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    9163     break;
    9164 
    9165   case 746:
    9166 
    9167 /* Line 1806 of yacc.c  */
    9168 #line 2818 "parser.yy"
    9169     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9170     break;
    9171 
    91729172  case 747:
    91739173
    91749174/* Line 1806 of yacc.c  */
    9175 #line 2823 "parser.yy"
     9175#line 2821 "parser.yy"
    91769176    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    91779177    break;
    … …  
    91809180
    91819181/* Line 1806 of yacc.c  */
     9182#line 2826 "parser.yy"
     9183    { (yyval.decl) = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), (yyvsp[(4) - (5)].decl), nullptr ); }
     9184    break;
     9185
     9186  case 749:
     9187
     9188/* Line 1806 of yacc.c  */
    91829189#line 2828 "parser.yy"
    9183     { (yyval.decl) = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), (yyvsp[(4) - (5)].decl), nullptr ); }
    9184     break;
    9185 
    9186   case 749:
     9190    { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     9191    break;
     9192
     9193  case 750:
    91879194
    91889195/* Line 1806 of yacc.c  */
    … …  
    91919198    break;
    91929199
    9193   case 750:
    9194 
    9195 /* Line 1806 of yacc.c  */
    9196 #line 2832 "parser.yy"
    9197     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
    9198     break;
    9199 
    92009200  case 753:
    92019201
    92029202/* Line 1806 of yacc.c  */
     9203#line 2854 "parser.yy"
     9204    { (yyval.en) = 0; }
     9205    break;
     9206
     9207  case 754:
     9208
     9209/* Line 1806 of yacc.c  */
    92039210#line 2856 "parser.yy"
    9204     { (yyval.en) = 0; }
    9205     break;
    9206 
    9207   case 754:
    9208 
    9209 /* Line 1806 of yacc.c  */
    9210 #line 2858 "parser.yy"
    92119211    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    92129212    break;
    … …  
    94469446
    94479447/* Line 2067 of yacc.c  */
    9448 #line 2861 "parser.yy"
     9448#line 2859 "parser.yy"
    94499449
    94509450// ----end of grammar----

  • src/Parser/parser.yy

    ra1e67dd rf0121d7  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct 19 22:19:33 2016
    13 // Update Count     : 2003
     12// Last Modified On : Wed Oct  5 14:10:46 2016
     13// Update Count     : 2002
    1414//
    1515
    … …  
    277277//
    278278// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those
    279 // introduced through "forall" qualifiers), and by introducing "type generators" -- parameterized types.  This latter
     279// introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types.  This latter
    280280// type name creates a third class of identifiers that must be distinguished by the scanner.
    281281//
    282282// Since the scanner cannot distinguish among the different classes of identifiers without some context information, it
    283 // accesses a data structure (TypedefTable) to allow classification of an identifier that it has just read.  Semantic
    284 // actions during the parser update this data structure when the class of identifiers change.
     283// accesses a data structure (the TypedefTable) to allow classification of an identifier that it has just read.
     284// Semantic actions during the parser update this data structure when the class of identifiers change.
    285285//
    286286// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its class in a
    … …  
    288288// particular declaration, each declaration is itself a scope.  This requires distinguishing between type names that are
    289289// local to the current declaration scope and those that persist past the end of the declaration (i.e., names defined in
    290 // "typedef" or "otype" declarations).
     290// "typedef" or "type" declarations).
    291291//
    292292// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and closing of
    … …  
    433433        no_attr_identifier
    434434                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    435                 // x.1, x.[0, 0.0]
    436435        | INTEGERconstant
    437436                { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
    … …  
    27272726        | multi_array_dimension type_specifier
    27282727                { $$ = $2->addNewArray( $1 ); }
    2729 
    27302728        | '[' ']' new_identifier_parameter_ptr
    27312729                { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
Note: See TracChangeset for help on using the changeset viewer.