Changeset a1e67dd


Ignore:
Timestamp:
Oct 26, 2016, 11:03:01 AM (5 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
77971f6
Parents:
f0121d7 (diff), fe7b281 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into tuples

Conflicts:

src/Parser/parser.cc
src/Parser/parser.yy

Files:
6 added
9 edited

Legend:

Unmodified
Added
Removed
  • doc/LaTeXmacros/common.tex

    rf0121d7 ra1e67dd  
    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
    4345
    4446%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
    124126\newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
    125127
    126 % inline text and code index (cannot use ©)
     128% inline text and code index (cannot use �)
    127129\newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
    128 % code index (cannot use ©)
     130% code index (cannot use �)
    129131\newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
    130132
     
    226228
    227229% CFA programming language, based on ANSI C (with some gcc additions)
    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__,},
     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]{`}{`},%
    233238}%
    234239
    235240\lstset{
    236 language=CFA,
     241language=Pseudo,
    237242columns=fullflexible,
    238 basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
    239 stringstyle=\tt,                                                % use typewriter font
    240 tabsize=4,                                                              % 4 space tabbing
     243basicstyle=\linespread{0.9}\tt\small,           % reduce line spacing and use typewriter font
     244stringstyle=\sf\color{Mahogany},                        % use sanserif font
     245commentstyle=\itshape\color{OliveGreen},                % green and italic comments
     246tabsize=4,                                                      % 4 space tabbing
    241247xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
    242 extendedchars=true,                                             % allow ASCII characters in the range 128-255
    243 escapechar=§,                                                   % escape to latex in CFA code
     248extendedchars=true,                                     % allow ASCII characters in the range 128-255
     249escapechar=§,                                           % escape to latex in CFA code
    244250mathescape=true,                                                % allow $...$ LaTeX math escapes in code
    245 %keepspaces=true,                                               % 
     251%keepspaces=true,                                               %
    246252showstringspaces=false,                                 % do not show spaces with cup
    247 showlines=true,                                                 % show blank lines at end of code
    248 aboveskip=4pt,                                                  % spacing above/below code block
     253showlines=true,                                         % show blank lines at end of code
     254aboveskip=4pt,                                          % spacing above/below code block
    249255belowskip=3pt,
    250256moredelim=**[is][\color{red}]{®}{®},    % red highlighting
     
    253259moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
    254260% replace/adjust listing characters that look bad in sanserif
    255 literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
     261literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 {©}{{\"u}}1
    256262        {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
    257263        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2,
    258264}%
    259265
     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{
     276language=CFA,
     277columns=fullflexible,
     278basicstyle=\linespread{0.9}\tt\small,           % reduce line spacing and use typewriter font
     279keywordstyle=[2]\color{blue},                           % second set of keywords for concurency
     280stringstyle=\sf\color{Mahogany},                        % use sanserif font
     281commentstyle=\itshape\color{OliveGreen},                % green and italic comments
     282tabsize=4,                                                      % 4 space tabbing
     283xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
     284extendedchars=true,                                     % allow ASCII characters in the range 128-255
     285escapechar=§,                                           % escape to latex in CFA code
     286mathescape=true,                                                % allow $...$ LaTeX math escapes in code
     287%keepspaces=true,                                               %
     288showstringspaces=false,                                 % do not show spaces with cup
     289showlines=true,                                         % show blank lines at end of code
     290aboveskip=4pt,                                          % spacing above/below code block
     291belowskip=3pt,
     292moredelim=**[is][\color{red}]{®}{®},    % red highlighting
     293moredelim=**[is][\color{blue}]{ß}{ß},   % blue highlighting
     294moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting
     295moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
     296% replace/adjust listing characters that look bad in sanserif
     297literate={-}{\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
    260302\lstMakeShortInline©    % single-character for \lstinline
     303
    261304
    262305\let\Oldthebibliography\thebibliography
  • doc/proposals/concurrency/Makefile

    rf0121d7 ra1e67dd  
    1212
    1313FIGURES = ${addsuffix .tex, \
     14        monitor \
     15        ext_monitor \
    1416}
    1517
     
    3234
    3335clean :
    34         rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist \
     36        rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist *.acn *.acr *.alg \
    3537                ${FIGURES} ${PICTURES} ${PROGRAMS} ${GRAPHS} ${basename ${DOCUMENT}}.ps ${DOCUMENT}
    3638
     
    5860        # Run again to get index title into table of contents
    5961        ${LaTeX} ${basename $@}.tex
     62        -./bump_ver.sh
    6063        ${LaTeX} ${basename $@}.tex
    6164
     
    7679        fig2dev -L pstex_t -p $@ $< > $@_t
    7780
     81
    7882# Local Variables: #
    7983# compile-command: "make" #
  • doc/proposals/concurrency/concurrency.tex

    rf0121d7 ra1e67dd  
    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{glossaries}
     26\usepackage[acronym]{glossaries}
    2727\usepackage{varioref}                                                           % extended references
    2828\usepackage{inconsolata}
     
    3333\usepackage[usenames]{color}
    3434\usepackage[pagewise]{lineno}
     35\usepackage{fancyhdr}
    3536\renewcommand{\linenumberfont}{\scriptsize\sffamily}
    3637\input{common}                                          % bespoke macros used in the document
    3738\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
    3839\usepackage{breakurl}
     40
     41\usepackage{tikz}
     42\def\checkmark{\tikz\fill[scale=0.4](0,.35) -- (.25,0) -- (1,.7) -- (.25,.15) -- cycle;}
    3943
    4044\renewcommand{\UrlFont}{\small\sf}
     
    5862\newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace}
    5963\newcommand{\code}[1]{\lstinline{#1}}
     64\newcommand{\pseudo}[1]{\lstinline[language=Pseudo]{#1}}
    6065
    6166\input{glossary}
     
    6772\setcounter{secnumdepth}{3}                             % number subsubsections
    6873\setcounter{tocdepth}{3}                                % subsubsections in table of contents
     74% \linenumbers                                            % comment out to turn off line numbering
    6975\makeindex
     76\pagestyle{fancy}
     77\fancyhf{}
     78\cfoot{\thepage}
     79\rfoot{v\input{version}}
    7080
    7181%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
    8191\maketitle
    8292\section{Introduction}
    83 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 be to support higher level construct as the basis of the concurrency in \CFA.
    84 Indeed, 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 
    86 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 ressource utilisation.
     93This 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.
     94Indeed, 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
     96There 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.
    8797
    8898\section{Concurrency}
    89 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 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.
     99Several 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\\
    90101
    91102Finally, 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.
    92103
    93 \section{Monitors}
    94 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 to be able to declare a handle to a shared object and a set of routines that act on it :
     104\subsection{Monitors}
     105A 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 :
    95106\begin{lstlisting}
    96107        typedef /*some monitor type*/ monitor;
     
    103114\end{lstlisting}
    104115
    105 \subsection{Call semantics} \label{call}
    106 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 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 
    108 Another 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 :
     116\subsubsection{Call semantics} \label{call}
     117The 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
     120Another 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 :
    109121
    110122\begin{lstlisting}
    111123        mutex struct counter_t { /*...*/ };
    112124
    113         void ?{}(counter_t & mutex this);
     125        void ?{}(counter_t & nomutex this);
    114126        int ++?(counter_t & mutex this);
    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 
    124 This 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} ).
     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
     132This 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
     133uses \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\\
    125135
    126136Having 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\\
    127138
    128139Regardless of which keyword is kept, it is important to establish when mutex/nomutex may be used depending on type parameters.
    129140\begin{lstlisting}
    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 
    143 For 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}
     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
     148The 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}
    146151Once 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}:
    147152\begin{lstlisting}
     
    150155        };
    151156
    152         void ?{}(counter_t & mutex this) {
     157        void ?{}(counter_t & nomutex this) {
    153158                this.cnt = 0;
    154159        }
     
    165170Thread 1 & Thread 2 \\
    166171\begin{lstlisting}
    167         void main(counter_t & mutex c) {
     172        void f(counter_t & mutex c) {
    168173                for(;;) {
    169                         int count = c;
    170                         sout | count | endl;
     174                        sout | (int)c | endl;
    171175                }
    172176        }
    173177\end{lstlisting} &\begin{lstlisting}
    174         void main(counter_t & mutex c) {
     178        void g(counter_t & mutex c) {
    175179                for(;;) {
    176180                        ++c;
     
    194198\end{lstlisting}
    195199
    196 This 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 :
     200This 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 :
    197201\begin{lstlisting}
    198202        void foo(A & mutex a, B & mutex a) {
     
    213217\end{lstlisting}
    214218
    215 TODO: dig further into monitor order aquiring
    216 
    217 Thoughs : 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}
     219Recursive 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}
     222At 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
     224First 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}
    220227Monitors 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 :
    221228
     
    236243\end{lstlisting}
    237244
    238 Here 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.
     245Here 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.
    239246
    240247\begin{center}
     
    263270\end{center}
    264271
    265 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 :
     272A 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):
    266273
    267274\begin{center}
     
    270277\hline
    271278\begin{lstlisting}
     279condition e;
     280
    272281void foo(monitor & mutex a,
    273282         monitor & mutex b) {
    274         wait(a.e);
     283        wait(e);
    275284}
    276285
     
    282291foo(a,b);
    283292\end{lstlisting} &\begin{lstlisting}
     293condition e;
     294
    284295void bar(monitor & mutex a,
    285296         monitor & nomutex b) {
     
    289300void foo(monitor & mutex a,
    290301         monitor & mutex b) {
    291         wait(a.e);
     302        wait(e);
    292303}
    293304
    294305bar(a, b);
    295306\end{lstlisting} &\begin{lstlisting}
     307condition e;
     308
    296309void bar(monitor & mutex a,
    297310         monitor & nomutex b) {
     
    301314void baz(monitor & nomutex a,
    302315         monitor & mutex b) {
    303         wait(a.e);
     316        wait(e);
    304317}
    305318
     
    310323
    311324This can be interpreted in two different ways :
     325\begin{flushleft}
    312326\begin{enumerate}
    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.
     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.
    315329\end{enumerate}
    316 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.
     330\end{flushleft}
     331While 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. :
    317332
    318333\begin{center}
     
    334349\end{center}
    335350
    336 This 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.
     351This 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.
    337352\\
    338353
     
    411426\\
    412427
    413 All 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 :
     428All 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 :
    414429\begin{lstlisting}
    415430void wait(condition & cond) {
     
    419434This 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 :
    420435\begin{lstlisting}
    421 extern void doStuff();
     436monitor global;
     437
     438extern void doStuff(); //uses global
    422439
    423440void foo(monitor & mutex m) {
     
    426443        //...
    427444}
    428 \end{lstlisting}
    429 
    430 Indeed, 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 :
     445
     446foo(global);
     447\end{lstlisting}
     448
     449Indeed, 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 :
    431450\begin{lstlisting}
    432451struct condition { /*...*/ };
     
    443462\end{lstlisting}
    444463
    445 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) than the call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
     464Regardless 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.
    446465
    447466Finally, 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\\
    448468
    449469\subsection{External scheduling} \label{extsched}
    450 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 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.
     470As 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.
    451471
    452472\begin{center}
     
    458478                condition c;
    459479        public:
    460                 void f();
    461                 void g() { signal}
    462                 void h() { wait(c); }
     480                void f() { signal(c)}
     481                void g() { wait(c); }
    463482        private:
    464483        }
     
    468487        public:
    469488                void f();
    470                 void g();
    471                 void h() { _Accept(g); }
     489                void g() { _Accept(f); }
    472490        private:
    473491        }
     
    477495
    478496In 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\\
    479498
    480499\subsubsection{Loose object definitions}
    481 In \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 :
     500In \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 :
    482501
    483502\begin{lstlisting}
     
    485504
    486505        void f(A & mutex a);
    487         void g(A & mutex a);
    488         void h(A & mutex a) { accept(g); }
    489 \end{lstlisting}
    490 
    491 While 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 
    500 This 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}
     506        void g(A & mutex a) { accept(f); }
     507\end{lstlisting}
     508
     509However, 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 :
     510
     511\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
     520\end{lstlisting}
     521\end{tabular}
     522\end{center}
     523
     524For 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
     530There 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.
     531The 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
     537Not 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
     539At 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
     541In 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
    502548Alternative 1 & Alternative 2 \\
    503549\begin{lstlisting}
    504550mutex struct A
    505 accept( void g(A & mutex a) )
     551accept( void f(A & mutex a) )
    506552{};
    507553\end{lstlisting} &\begin{lstlisting}
    508554mutex struct A {}
    509 accept( void g(A & mutex a) );
     555accept( void f(A & mutex a) );
    510556
    511557\end{lstlisting} \\
     
    513559\begin{lstlisting}
    514560mutex struct A {
    515         accept( void g(A & mutex a) )
     561        accept( void f(A & mutex a) )
    516562};
    517563
     
    519565mutex struct A {
    520566        accept :
    521                 void g(A & mutex a) );
     567                void f(A & mutex a) );
    522568};
    523 \end{lstlisting}
     569\end{lstlisting}\\
     570\hline
     571\multicolumn{2}{ c }{\code{accept} on routine}\\
     572\hline
     573\begin{lstlisting}
     574mutex struct A {};
     575
     576void f(A & mutex a)
     577
     578accept( void f(A & mutex a) )
     579void g(A & mutex a) {
     580        /*...*/
     581}
     582\end{lstlisting}&\\
    524583\end{tabular}
    525 
     584}
     585\end{center}
    526586
    527587An 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.
     
    554614\end{lstlisting}
    555615
    556 This 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.
     616This 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.
    557617
    558618\begin{lstlisting}
     
    569629Note 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.
    570630
    571 \subsection{Implementation Details}
    572 \textbf{\large{Work in progress...}}
    573 \subsubsection{Interaction with polymorphism}
    574 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.
    575 
    576 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.
    577 
    578 \subsubsection{External scheduling queues}
    579 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 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.
     631\subsubsection{Implementation Details: External scheduling queues}
     632To 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.
    580633
    581634\subsection{Other concurrency tools}
    582 
     635TO BE CONTINUED...
     636
     637\newpage
    583638\section{Parallelism}
    584 Historically, 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.
     639Historically, 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.
    585640
    586641\subsection{User-level threads}
     
    590645
    591646\subsection{Jobs and thread pools}
    592 The 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}.
     647The 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.
     648The golden standard of this implementation is Intel's TBB library\cite{TBB}.
    593649
    594650\subsection{Fibers : user-level threads without preemption}
    595651Finally, 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}
     652An example of a language that uses fibers is Go\cite{Go}
    597653
    598654\subsection{Paradigm performance}
    599 While 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.
    600 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.
    601 
    602 \section{Parallelism in \CFA}
    603 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.
    604 
    605 \subsection{Kernel core}\label{kernel}
    606 At 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}
    613 constructors destructors
    614         initializer lists
    615 monitors
    616 
    617 \subsubsection{Futures}
    618 
    619 \subsubsection{Implicit threading}
    620 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.
    621 
    622 \begin{center}
    623 \begin{tabular}[t]{|c|c|c|}
    624 Sequential & System Parallel & Language Parallel \\
    625 \begin{lstlisting}
    626 void 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 
    639 int* a[10000];
    640 int* b[10000];
    641 int* c[10000];
    642 //... fill in a and b ...
    643 big_sum(a, b, c, 10000);
    644 \end{lstlisting} &\begin{lstlisting}
    645 void 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 
    658 int* a[10000];
    659 int* b[10000];
    660 int* c[10000];
    661 //... fill in a and b ...
    662 big_sum(a, b, c, 10000);
    663 \end{lstlisting}&\begin{lstlisting}
    664 void 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 
    677 int* a[10000];
    678 int* b[10000];
    679 int* c[10000];
    680 //... fill in a and b ...
    681 big_sum(a, b, c, 10000);
    682 \end{lstlisting}
     655While 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}
     658As 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
    683670\end{tabular}
    684671\end{center}
    685672
    686 \subsection{Machine setup}\label{machine}
    687 Threads 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?
     673As 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}
     676The 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
     682Obviously, 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
     691With 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
     712Of 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}
     714thread struct FuncRunner; //FuncRunner declared above
     715
     716void world() {
     717        sout | "World!" | endl;
     718}
     719
     720void 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}
     730This 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
     732These 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}
     762Given 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}
    690846
    691847\section{Future work}
     
    696852
    697853\clearpage
     854\printglossary[type=\acronymtype]
    698855\printglossary
    699856
  • doc/proposals/concurrency/glossary.tex

    rf0121d7 ra1e67dd  
    3131\textit{Synonyms : Tasks.}
    3232}
     33
     34\longnewglossaryentry{cfacluster}
     35{name={cluster}}
     36{
     37TBD...
     38
     39\textit{Synonyms : None.}
     40}
     41
     42\longnewglossaryentry{cfacpu}
     43{name={processor}}
     44{
     45TBD...
     46
     47\textit{Synonyms : None.}
     48}
     49
     50\longnewglossaryentry{cfathread}
     51{name={thread}}
     52{
     53TBD...
     54
     55\textit{Synonyms : None.}
     56}
     57
     58\longnewglossaryentry{preemption}
     59{name={preemption}}
     60{
     61TBD...
     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

    rf0121d7 ra1e67dd  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Aug 14 08:23:06 2016
    14 %% Update Count     : 1323
     13%% Last Modified On : Thu Sep 29 11:50:28 2016
     14%% Update Count     : 1325
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    3333\usepackage{textcomp}
    3434\usepackage[latin1]{inputenc}
     35
    3536\usepackage{fullpage,times,comment}
    3637\usepackage{epic,eepic}
     
    18531854case 1:  case 2:  case 3: ...
    18541855\end{lstlisting}
    1855 still work.
     1856still works.
    18561857Nevertheless, 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
    1858 Therefore, 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 =======
    18601858Therefore, 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
    18621859\begin{lstlisting}
    18631860®choose® ( i ) {
  • src/Parser/lex.cc

    rf0121d7 ra1e67dd  
    14691469 * Created On       : Sat Sep 22 08:58:10 2001
    14701470 * Last Modified By : Peter A. Buhr
    1471  * Last Modified On : Wed Aug 24 13:27:04 2016
    1472  * Update Count     : 487
     1471 * Last Modified On : Tue Oct 18 22:19:37 2016
     1472 * Update Count     : 488
    14731473 */
    14741474#line 20 "lex.ll"
     
    15171517
    15181518// identifier, GCC: $ in identifier
    1519 // quoted identifier
    15201519// attribute identifier, GCC: $ in identifier
    15211520// numeric constants, CFA: '_' in constant
     
    15321531
    15331532
    1534 #line 1535 "Parser/lex.cc"
     1533#line 1534 "Parser/lex.cc"
    15351534
    15361535#define INITIAL 0
     
    17241723        register int yy_act;
    17251724   
    1726 #line 139 "lex.ll"
     1725#line 136 "lex.ll"
    17271726
    17281727                                   /* line directives */
    1729 #line 1730 "Parser/lex.cc"
     1728#line 1729 "Parser/lex.cc"
    17301729
    17311730        if ( !(yy_init) )
     
    18241823/* rule 1 can match eol */
    18251824YY_RULE_SETUP
    1826 #line 141 "lex.ll"
     1825#line 138 "lex.ll"
    18271826{
    18281827        /* " stop highlighting */
     
    18501849/* rule 2 can match eol */
    18511850YY_RULE_SETUP
    1852 #line 163 "lex.ll"
     1851#line 160 "lex.ll"
    18531852;
    18541853        YY_BREAK
     
    18561855case 3:
    18571856YY_RULE_SETUP
    1858 #line 166 "lex.ll"
     1857#line 163 "lex.ll"
    18591858{ BEGIN COMMENT; }
    18601859        YY_BREAK
     
    18621861/* rule 4 can match eol */
    18631862YY_RULE_SETUP
    1864 #line 167 "lex.ll"
     1863#line 164 "lex.ll"
    18651864;
    18661865        YY_BREAK
    18671866case 5:
    18681867YY_RULE_SETUP
    1869 #line 168 "lex.ll"
     1868#line 165 "lex.ll"
    18701869{ BEGIN 0; }
    18711870        YY_BREAK
     
    18741873/* rule 6 can match eol */
    18751874YY_RULE_SETUP
    1876 #line 171 "lex.ll"
     1875#line 168 "lex.ll"
    18771876;
    18781877        YY_BREAK
     
    18801879case 7:
    18811880YY_RULE_SETUP
    1882 #line 174 "lex.ll"
     1881#line 171 "lex.ll"
    18831882{ WHITE_RETURN(' '); }
    18841883        YY_BREAK
    18851884case 8:
    18861885YY_RULE_SETUP
    1887 #line 175 "lex.ll"
     1886#line 172 "lex.ll"
    18881887{ WHITE_RETURN(' '); }
    18891888        YY_BREAK
     
    18911890/* rule 9 can match eol */
    18921891YY_RULE_SETUP
    1893 #line 176 "lex.ll"
     1892#line 173 "lex.ll"
    18941893{ NEWLINE_RETURN(); }
    18951894        YY_BREAK
     
    18971896case 10:
    18981897YY_RULE_SETUP
     1898#line 176 "lex.ll"
     1899{ KEYWORD_RETURN(ALIGNAS); }                    // C11
     1900        YY_BREAK
     1901case 11:
     1902YY_RULE_SETUP
     1903#line 177 "lex.ll"
     1904{ KEYWORD_RETURN(ALIGNOF); }                    // C11
     1905        YY_BREAK
     1906case 12:
     1907YY_RULE_SETUP
     1908#line 178 "lex.ll"
     1909{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
     1910        YY_BREAK
     1911case 13:
     1912YY_RULE_SETUP
    18991913#line 179 "lex.ll"
    1900 { KEYWORD_RETURN(ALIGNAS); }                    // C11
    1901         YY_BREAK
    1902 case 11:
     1914{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
     1915        YY_BREAK
     1916case 14:
    19031917YY_RULE_SETUP
    19041918#line 180 "lex.ll"
    1905 { KEYWORD_RETURN(ALIGNOF); }                    // C11
    1906         YY_BREAK
    1907 case 12:
     1919{ KEYWORD_RETURN(ASM); }
     1920        YY_BREAK
     1921case 15:
    19081922YY_RULE_SETUP
    19091923#line 181 "lex.ll"
    1910 { KEYWORD_RETURN(ALIGNOF); }                    // GCC
    1911         YY_BREAK
    1912 case 13:
     1924{ KEYWORD_RETURN(ASM); }                                // GCC
     1925        YY_BREAK
     1926case 16:
    19131927YY_RULE_SETUP
    19141928#line 182 "lex.ll"
    1915 { KEYWORD_RETURN(ALIGNOF); }                    // GCC
    1916         YY_BREAK
    1917 case 14:
     1929{ KEYWORD_RETURN(ASM); }                                // GCC
     1930        YY_BREAK
     1931case 17:
    19181932YY_RULE_SETUP
    19191933#line 183 "lex.ll"
    1920 { KEYWORD_RETURN(ASM); }
    1921         YY_BREAK
    1922 case 15:
     1934{ KEYWORD_RETURN(AT); }                                 // CFA
     1935        YY_BREAK
     1936case 18:
    19231937YY_RULE_SETUP
    19241938#line 184 "lex.ll"
    1925 { KEYWORD_RETURN(ASM); }                                // GCC
    1926         YY_BREAK
    1927 case 16:
     1939{ KEYWORD_RETURN(ATOMIC); }                             // C11
     1940        YY_BREAK
     1941case 19:
    19281942YY_RULE_SETUP
    19291943#line 185 "lex.ll"
    1930 { KEYWORD_RETURN(ASM); }                                // GCC
    1931         YY_BREAK
    1932 case 17:
     1944{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
     1945        YY_BREAK
     1946case 20:
    19331947YY_RULE_SETUP
    19341948#line 186 "lex.ll"
    1935 { KEYWORD_RETURN(AT); }                                 // CFA
    1936         YY_BREAK
    1937 case 18:
     1949{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
     1950        YY_BREAK
     1951case 21:
    19381952YY_RULE_SETUP
    19391953#line 187 "lex.ll"
    1940 { KEYWORD_RETURN(ATOMIC); }                             // C11
    1941         YY_BREAK
    1942 case 19:
     1954{ KEYWORD_RETURN(AUTO); }
     1955        YY_BREAK
     1956case 22:
    19431957YY_RULE_SETUP
    19441958#line 188 "lex.ll"
    1945 { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    1946         YY_BREAK
    1947 case 20:
     1959{ KEYWORD_RETURN(BOOL); }                               // C99
     1960        YY_BREAK
     1961case 23:
    19481962YY_RULE_SETUP
    19491963#line 189 "lex.ll"
    1950 { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    1951         YY_BREAK
    1952 case 21:
     1964{ KEYWORD_RETURN(BREAK); }
     1965        YY_BREAK
     1966case 24:
    19531967YY_RULE_SETUP
    19541968#line 190 "lex.ll"
    1955 { KEYWORD_RETURN(AUTO); }
    1956         YY_BREAK
    1957 case 22:
     1969{ KEYWORD_RETURN(CASE); }
     1970        YY_BREAK
     1971case 25:
    19581972YY_RULE_SETUP
    19591973#line 191 "lex.ll"
    1960 { KEYWORD_RETURN(BOOL); }                               // C99
    1961         YY_BREAK
    1962 case 23:
     1974{ KEYWORD_RETURN(CATCH); }                              // CFA
     1975        YY_BREAK
     1976case 26:
    19631977YY_RULE_SETUP
    19641978#line 192 "lex.ll"
    1965 { KEYWORD_RETURN(BREAK); }
    1966         YY_BREAK
    1967 case 24:
     1979{ KEYWORD_RETURN(CATCHRESUME); }                // CFA
     1980        YY_BREAK
     1981case 27:
    19681982YY_RULE_SETUP
    19691983#line 193 "lex.ll"
    1970 { KEYWORD_RETURN(CASE); }
    1971         YY_BREAK
    1972 case 25:
     1984{ KEYWORD_RETURN(CHAR); }
     1985        YY_BREAK
     1986case 28:
    19731987YY_RULE_SETUP
    19741988#line 194 "lex.ll"
    1975 { KEYWORD_RETURN(CATCH); }                              // CFA
    1976         YY_BREAK
    1977 case 26:
     1989{ KEYWORD_RETURN(CHOOSE); }                             // CFA
     1990        YY_BREAK
     1991case 29:
    19781992YY_RULE_SETUP
    19791993#line 195 "lex.ll"
    1980 { KEYWORD_RETURN(CATCHRESUME); }                // CFA
    1981         YY_BREAK
    1982 case 27:
     1994{ KEYWORD_RETURN(COMPLEX); }                    // C99
     1995        YY_BREAK
     1996case 30:
    19831997YY_RULE_SETUP
    19841998#line 196 "lex.ll"
    1985 { KEYWORD_RETURN(CHAR); }
    1986         YY_BREAK
    1987 case 28:
     1999{ KEYWORD_RETURN(COMPLEX); }                    // GCC
     2000        YY_BREAK
     2001case 31:
    19882002YY_RULE_SETUP
    19892003#line 197 "lex.ll"
    1990 { KEYWORD_RETURN(CHOOSE); }                             // CFA
    1991         YY_BREAK
    1992 case 29:
     2004{ KEYWORD_RETURN(COMPLEX); }                    // GCC
     2005        YY_BREAK
     2006case 32:
    19932007YY_RULE_SETUP
    19942008#line 198 "lex.ll"
    1995 { KEYWORD_RETURN(COMPLEX); }                    // C99
    1996         YY_BREAK
    1997 case 30:
     2009{ KEYWORD_RETURN(CONST); }
     2010        YY_BREAK
     2011case 33:
    19982012YY_RULE_SETUP
    19992013#line 199 "lex.ll"
    2000 { KEYWORD_RETURN(COMPLEX); }                    // GCC
    2001         YY_BREAK
    2002 case 31:
     2014{ KEYWORD_RETURN(CONST); }                              // GCC
     2015        YY_BREAK
     2016case 34:
    20032017YY_RULE_SETUP
    20042018#line 200 "lex.ll"
    2005 { KEYWORD_RETURN(COMPLEX); }                    // GCC
    2006         YY_BREAK
    2007 case 32:
     2019{ KEYWORD_RETURN(CONST); }                              // GCC
     2020        YY_BREAK
     2021case 35:
    20082022YY_RULE_SETUP
    20092023#line 201 "lex.ll"
    2010 { KEYWORD_RETURN(CONST); }
    2011         YY_BREAK
    2012 case 33:
     2024{ KEYWORD_RETURN(CONTINUE); }
     2025        YY_BREAK
     2026case 36:
    20132027YY_RULE_SETUP
    20142028#line 202 "lex.ll"
    2015 { KEYWORD_RETURN(CONST); }                              // GCC
    2016         YY_BREAK
    2017 case 34:
     2029{ KEYWORD_RETURN(DEFAULT); }
     2030        YY_BREAK
     2031case 37:
    20182032YY_RULE_SETUP
    20192033#line 203 "lex.ll"
    2020 { KEYWORD_RETURN(CONST); }                              // GCC
    2021         YY_BREAK
    2022 case 35:
     2034{ KEYWORD_RETURN(DISABLE); }                    // CFA
     2035        YY_BREAK
     2036case 38:
    20232037YY_RULE_SETUP
    20242038#line 204 "lex.ll"
    2025 { KEYWORD_RETURN(CONTINUE); }
    2026         YY_BREAK
    2027 case 36:
     2039{ KEYWORD_RETURN(DO); }
     2040        YY_BREAK
     2041case 39:
    20282042YY_RULE_SETUP
    20292043#line 205 "lex.ll"
    2030 { KEYWORD_RETURN(DEFAULT); }
    2031         YY_BREAK
    2032 case 37:
     2044{ KEYWORD_RETURN(DOUBLE); }
     2045        YY_BREAK
     2046case 40:
    20332047YY_RULE_SETUP
    20342048#line 206 "lex.ll"
    2035 { KEYWORD_RETURN(DISABLE); }                    // CFA
    2036         YY_BREAK
    2037 case 38:
     2049{ KEYWORD_RETURN(DTYPE); }                              // CFA
     2050        YY_BREAK
     2051case 41:
    20382052YY_RULE_SETUP
    20392053#line 207 "lex.ll"
    2040 { KEYWORD_RETURN(DO); }
    2041         YY_BREAK
    2042 case 39:
     2054{ KEYWORD_RETURN(ELSE); }
     2055        YY_BREAK
     2056case 42:
    20432057YY_RULE_SETUP
    20442058#line 208 "lex.ll"
    2045 { KEYWORD_RETURN(DOUBLE); }
    2046         YY_BREAK
    2047 case 40:
     2059{ KEYWORD_RETURN(ENABLE); }                             // CFA
     2060        YY_BREAK
     2061case 43:
    20482062YY_RULE_SETUP
    20492063#line 209 "lex.ll"
    2050 { KEYWORD_RETURN(DTYPE); }                              // CFA
    2051         YY_BREAK
    2052 case 41:
     2064{ KEYWORD_RETURN(ENUM); }
     2065        YY_BREAK
     2066case 44:
    20532067YY_RULE_SETUP
    20542068#line 210 "lex.ll"
    2055 { KEYWORD_RETURN(ELSE); }
    2056         YY_BREAK
    2057 case 42:
     2069{ KEYWORD_RETURN(EXTENSION); }                  // GCC
     2070        YY_BREAK
     2071case 45:
    20582072YY_RULE_SETUP
    20592073#line 211 "lex.ll"
    2060 { KEYWORD_RETURN(ENABLE); }                             // CFA
    2061         YY_BREAK
    2062 case 43:
     2074{ KEYWORD_RETURN(EXTERN); }
     2075        YY_BREAK
     2076case 46:
    20632077YY_RULE_SETUP
    20642078#line 212 "lex.ll"
    2065 { KEYWORD_RETURN(ENUM); }
    2066         YY_BREAK
    2067 case 44:
     2079{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
     2080        YY_BREAK
     2081case 47:
    20682082YY_RULE_SETUP
    20692083#line 213 "lex.ll"
    2070 { KEYWORD_RETURN(EXTENSION); }                  // GCC
    2071         YY_BREAK
    2072 case 45:
     2084{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
     2085        YY_BREAK
     2086case 48:
    20732087YY_RULE_SETUP
    20742088#line 214 "lex.ll"
    2075 { KEYWORD_RETURN(EXTERN); }
    2076         YY_BREAK
    2077 case 46:
     2089{ KEYWORD_RETURN(FINALLY); }                    // CFA
     2090        YY_BREAK
     2091case 49:
    20782092YY_RULE_SETUP
    20792093#line 215 "lex.ll"
    2080 { KEYWORD_RETURN(FALLTHRU); }                   // CFA
    2081         YY_BREAK
    2082 case 47:
     2094{ KEYWORD_RETURN(FLOAT); }
     2095        YY_BREAK
     2096case 50:
    20832097YY_RULE_SETUP
    20842098#line 216 "lex.ll"
    2085 { KEYWORD_RETURN(FALLTHRU); }                   // CFA
    2086         YY_BREAK
    2087 case 48:
     2099{ KEYWORD_RETURN(FLOAT); }                              // GCC
     2100        YY_BREAK
     2101case 51:
    20882102YY_RULE_SETUP
    20892103#line 217 "lex.ll"
    2090 { KEYWORD_RETURN(FINALLY); }                    // CFA
    2091         YY_BREAK
    2092 case 49:
     2104{ KEYWORD_RETURN(FOR); }
     2105        YY_BREAK
     2106case 52:
    20932107YY_RULE_SETUP
    20942108#line 218 "lex.ll"
    2095 { KEYWORD_RETURN(FLOAT); }
    2096         YY_BREAK
    2097 case 50:
     2109{ KEYWORD_RETURN(FORALL); }                             // CFA
     2110        YY_BREAK
     2111case 53:
    20982112YY_RULE_SETUP
    20992113#line 219 "lex.ll"
    2100 { KEYWORD_RETURN(FLOAT); }                              // GCC
    2101         YY_BREAK
    2102 case 51:
     2114{ KEYWORD_RETURN(FORTRAN); }
     2115        YY_BREAK
     2116case 54:
    21032117YY_RULE_SETUP
    21042118#line 220 "lex.ll"
    2105 { KEYWORD_RETURN(FOR); }
    2106         YY_BREAK
    2107 case 52:
     2119{ KEYWORD_RETURN(FTYPE); }                              // CFA
     2120        YY_BREAK
     2121case 55:
    21082122YY_RULE_SETUP
    21092123#line 221 "lex.ll"
    2110 { KEYWORD_RETURN(FORALL); }                             // CFA
    2111         YY_BREAK
    2112 case 53:
     2124{ KEYWORD_RETURN(GENERIC); }                    // C11
     2125        YY_BREAK
     2126case 56:
    21132127YY_RULE_SETUP
    21142128#line 222 "lex.ll"
    2115 { KEYWORD_RETURN(FORTRAN); }
    2116         YY_BREAK
    2117 case 54:
     2129{ KEYWORD_RETURN(GOTO); }
     2130        YY_BREAK
     2131case 57:
    21182132YY_RULE_SETUP
    21192133#line 223 "lex.ll"
    2120 { KEYWORD_RETURN(FTYPE); }                              // CFA
    2121         YY_BREAK
    2122 case 55:
     2134{ KEYWORD_RETURN(IF); }
     2135        YY_BREAK
     2136case 58:
    21232137YY_RULE_SETUP
    21242138#line 224 "lex.ll"
    2125 { KEYWORD_RETURN(GENERIC); }                    // C11
    2126         YY_BREAK
    2127 case 56:
     2139{ KEYWORD_RETURN(IMAGINARY); }                  // C99
     2140        YY_BREAK
     2141case 59:
    21282142YY_RULE_SETUP
    21292143#line 225 "lex.ll"
    2130 { KEYWORD_RETURN(GOTO); }
    2131         YY_BREAK
    2132 case 57:
     2144{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
     2145        YY_BREAK
     2146case 60:
    21332147YY_RULE_SETUP
    21342148#line 226 "lex.ll"
    2135 { KEYWORD_RETURN(IF); }
    2136         YY_BREAK
    2137 case 58:
     2149{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
     2150        YY_BREAK
     2151case 61:
    21382152YY_RULE_SETUP
    21392153#line 227 "lex.ll"
    2140 { KEYWORD_RETURN(IMAGINARY); }                  // C99
    2141         YY_BREAK
    2142 case 59:
     2154{ KEYWORD_RETURN(INLINE); }                             // C99
     2155        YY_BREAK
     2156case 62:
    21432157YY_RULE_SETUP
    21442158#line 228 "lex.ll"
    2145 { KEYWORD_RETURN(IMAGINARY); }                  // GCC
    2146         YY_BREAK
    2147 case 60:
     2159{ KEYWORD_RETURN(INLINE); }                             // GCC
     2160        YY_BREAK
     2161case 63:
    21482162YY_RULE_SETUP
    21492163#line 229 "lex.ll"
    2150 { KEYWORD_RETURN(IMAGINARY); }                  // GCC
    2151         YY_BREAK
    2152 case 61:
     2164{ KEYWORD_RETURN(INLINE); }                             // GCC
     2165        YY_BREAK
     2166case 64:
    21532167YY_RULE_SETUP
    21542168#line 230 "lex.ll"
    2155 { KEYWORD_RETURN(INLINE); }                             // C99
    2156         YY_BREAK
    2157 case 62:
     2169{ KEYWORD_RETURN(INT); }
     2170        YY_BREAK
     2171case 65:
    21582172YY_RULE_SETUP
    21592173#line 231 "lex.ll"
    2160 { KEYWORD_RETURN(INLINE); }                             // GCC
    2161         YY_BREAK
    2162 case 63:
     2174{ KEYWORD_RETURN(INT); }                                // GCC
     2175        YY_BREAK
     2176case 66:
    21632177YY_RULE_SETUP
    21642178#line 232 "lex.ll"
    2165 { KEYWORD_RETURN(INLINE); }                             // GCC
    2166         YY_BREAK
    2167 case 64:
     2179{ KEYWORD_RETURN(LABEL); }                              // GCC
     2180        YY_BREAK
     2181case 67:
    21682182YY_RULE_SETUP
    21692183#line 233 "lex.ll"
    2170 { KEYWORD_RETURN(INT); }
    2171         YY_BREAK
    2172 case 65:
     2184{ KEYWORD_RETURN(LONG); }
     2185        YY_BREAK
     2186case 68:
    21732187YY_RULE_SETUP
    21742188#line 234 "lex.ll"
    2175 { KEYWORD_RETURN(INT); }                                // GCC
    2176         YY_BREAK
    2177 case 66:
     2189{ KEYWORD_RETURN(LVALUE); }                             // CFA
     2190        YY_BREAK
     2191case 69:
    21782192YY_RULE_SETUP
    21792193#line 235 "lex.ll"
    2180 { KEYWORD_RETURN(LABEL); }                              // GCC
    2181         YY_BREAK
    2182 case 67:
     2194{ KEYWORD_RETURN(NORETURN); }                   // C11
     2195        YY_BREAK
     2196case 70:
    21832197YY_RULE_SETUP
    21842198#line 236 "lex.ll"
    2185 { KEYWORD_RETURN(LONG); }
    2186         YY_BREAK
    2187 case 68:
     2199{ KEYWORD_RETURN(OFFSETOF); }           // GCC
     2200        YY_BREAK
     2201case 71:
    21882202YY_RULE_SETUP
    21892203#line 237 "lex.ll"
    2190 { KEYWORD_RETURN(LVALUE); }                             // CFA
    2191         YY_BREAK
    2192 case 69:
     2204{ KEYWORD_RETURN(OTYPE); }                              // CFA
     2205        YY_BREAK
     2206case 72:
    21932207YY_RULE_SETUP
    21942208#line 238 "lex.ll"
    2195 { KEYWORD_RETURN(NORETURN); }                   // C11
    2196         YY_BREAK
    2197 case 70:
     2209{ KEYWORD_RETURN(REGISTER); }
     2210        YY_BREAK
     2211case 73:
    21982212YY_RULE_SETUP
    21992213#line 239 "lex.ll"
    2200 { KEYWORD_RETURN(OFFSETOF); }           // GCC
    2201         YY_BREAK
    2202 case 71:
     2214{ KEYWORD_RETURN(RESTRICT); }                   // C99
     2215        YY_BREAK
     2216case 74:
    22032217YY_RULE_SETUP
    22042218#line 240 "lex.ll"
    2205 { KEYWORD_RETURN(OTYPE); }                              // CFA
    2206         YY_BREAK
    2207 case 72:
     2219{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2220        YY_BREAK
     2221case 75:
    22082222YY_RULE_SETUP
    22092223#line 241 "lex.ll"
    2210 { KEYWORD_RETURN(REGISTER); }
    2211         YY_BREAK
    2212 case 73:
     2224{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2225        YY_BREAK
     2226case 76:
    22132227YY_RULE_SETUP
    22142228#line 242 "lex.ll"
    2215 { KEYWORD_RETURN(RESTRICT); }                   // C99
    2216         YY_BREAK
    2217 case 74:
     2229{ KEYWORD_RETURN(RETURN); }
     2230        YY_BREAK
     2231case 77:
    22182232YY_RULE_SETUP
    22192233#line 243 "lex.ll"
    2220 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    2221         YY_BREAK
    2222 case 75:
     2234{ KEYWORD_RETURN(SHORT); }
     2235        YY_BREAK
     2236case 78:
    22232237YY_RULE_SETUP
    22242238#line 244 "lex.ll"
    2225 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    2226         YY_BREAK
    2227 case 76:
     2239{ KEYWORD_RETURN(SIGNED); }
     2240        YY_BREAK
     2241case 79:
    22282242YY_RULE_SETUP
    22292243#line 245 "lex.ll"
    2230 { KEYWORD_RETURN(RETURN); }
    2231         YY_BREAK
    2232 case 77:
     2244{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2245        YY_BREAK
     2246case 80:
    22332247YY_RULE_SETUP
    22342248#line 246 "lex.ll"
    2235 { KEYWORD_RETURN(SHORT); }
    2236         YY_BREAK
    2237 case 78:
     2249{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2250        YY_BREAK
     2251case 81:
    22382252YY_RULE_SETUP
    22392253#line 247 "lex.ll"
    2240 { KEYWORD_RETURN(SIGNED); }
    2241         YY_BREAK
    2242 case 79:
     2254{ KEYWORD_RETURN(SIZEOF); }
     2255        YY_BREAK
     2256case 82:
    22432257YY_RULE_SETUP
    22442258#line 248 "lex.ll"
    2245 { KEYWORD_RETURN(SIGNED); }                             // GCC
    2246         YY_BREAK
    2247 case 80:
     2259{ KEYWORD_RETURN(STATIC); }
     2260        YY_BREAK
     2261case 83:
    22482262YY_RULE_SETUP
    22492263#line 249 "lex.ll"
    2250 { KEYWORD_RETURN(SIGNED); }                             // GCC
    2251         YY_BREAK
    2252 case 81:
     2264{ KEYWORD_RETURN(STATICASSERT); }               // C11
     2265        YY_BREAK
     2266case 84:
    22532267YY_RULE_SETUP
    22542268#line 250 "lex.ll"
    2255 { KEYWORD_RETURN(SIZEOF); }
    2256         YY_BREAK
    2257 case 82:
     2269{ KEYWORD_RETURN(STRUCT); }
     2270        YY_BREAK
     2271case 85:
    22582272YY_RULE_SETUP
    22592273#line 251 "lex.ll"
    2260 { KEYWORD_RETURN(STATIC); }
    2261         YY_BREAK
    2262 case 83:
     2274{ KEYWORD_RETURN(SWITCH); }
     2275        YY_BREAK
     2276case 86:
    22632277YY_RULE_SETUP
    22642278#line 252 "lex.ll"
    2265 { KEYWORD_RETURN(STATICASSERT); }               // C11
    2266         YY_BREAK
    2267 case 84:
     2279{ KEYWORD_RETURN(THREADLOCAL); }                // C11
     2280        YY_BREAK
     2281case 87:
    22682282YY_RULE_SETUP
    22692283#line 253 "lex.ll"
    2270 { KEYWORD_RETURN(STRUCT); }
    2271         YY_BREAK
    2272 case 85:
     2284{ KEYWORD_RETURN(THROW); }                              // CFA
     2285        YY_BREAK
     2286case 88:
    22732287YY_RULE_SETUP
    22742288#line 254 "lex.ll"
    2275 { KEYWORD_RETURN(SWITCH); }
    2276         YY_BREAK
    2277 case 86:
     2289{ KEYWORD_RETURN(THROWRESUME); }                // CFA
     2290        YY_BREAK
     2291case 89:
    22782292YY_RULE_SETUP
    22792293#line 255 "lex.ll"
    2280 { KEYWORD_RETURN(THREADLOCAL); }                // C11
    2281         YY_BREAK
    2282 case 87:
     2294{ KEYWORD_RETURN(TRAIT); }                              // CFA
     2295        YY_BREAK
     2296case 90:
    22832297YY_RULE_SETUP
    22842298#line 256 "lex.ll"
    2285 { KEYWORD_RETURN(THROW); }                              // CFA
    2286         YY_BREAK
    2287 case 88:
     2299{ KEYWORD_RETURN(TRY); }                                // CFA
     2300        YY_BREAK
     2301case 91:
    22882302YY_RULE_SETUP
    22892303#line 257 "lex.ll"
    2290 { KEYWORD_RETURN(THROWRESUME); }                // CFA
    2291         YY_BREAK
    2292 case 89:
     2304{ KEYWORD_RETURN(TYPEDEF); }
     2305        YY_BREAK
     2306case 92:
    22932307YY_RULE_SETUP
    22942308#line 258 "lex.ll"
    2295 { KEYWORD_RETURN(TRAIT); }                              // CFA
    2296         YY_BREAK
    2297 case 90:
     2309{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2310        YY_BREAK
     2311case 93:
    22982312YY_RULE_SETUP
    22992313#line 259 "lex.ll"
    2300 { KEYWORD_RETURN(TRY); }                                // CFA
    2301         YY_BREAK
    2302 case 91:
     2314{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2315        YY_BREAK
     2316case 94:
    23032317YY_RULE_SETUP
    23042318#line 260 "lex.ll"
    2305 { KEYWORD_RETURN(TYPEDEF); }
    2306         YY_BREAK
    2307 case 92:
     2319{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2320        YY_BREAK
     2321case 95:
    23082322YY_RULE_SETUP
    23092323#line 261 "lex.ll"
    2310 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2311         YY_BREAK
    2312 case 93:
     2324{ KEYWORD_RETURN(UNION); }
     2325        YY_BREAK
     2326case 96:
    23132327YY_RULE_SETUP
    23142328#line 262 "lex.ll"
    2315 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2316         YY_BREAK
    2317 case 94:
     2329{ KEYWORD_RETURN(UNSIGNED); }
     2330        YY_BREAK
     2331case 97:
    23182332YY_RULE_SETUP
    23192333#line 263 "lex.ll"
    2320 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2321         YY_BREAK
    2322 case 95:
     2334{ KEYWORD_RETURN(VALIST); }                     // GCC
     2335        YY_BREAK
     2336case 98:
    23232337YY_RULE_SETUP
    23242338#line 264 "lex.ll"
    2325 { KEYWORD_RETURN(UNION); }
    2326         YY_BREAK
    2327 case 96:
     2339{ KEYWORD_RETURN(VOID); }
     2340        YY_BREAK
     2341case 99:
    23282342YY_RULE_SETUP
    23292343#line 265 "lex.ll"
    2330 { KEYWORD_RETURN(UNSIGNED); }
    2331         YY_BREAK
    2332 case 97:
     2344{ KEYWORD_RETURN(VOLATILE); }
     2345        YY_BREAK
     2346case 100:
    23332347YY_RULE_SETUP
    23342348#line 266 "lex.ll"
    2335 { KEYWORD_RETURN(VALIST); }                     // GCC
    2336         YY_BREAK
    2337 case 98:
     2349{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2350        YY_BREAK
     2351case 101:
    23382352YY_RULE_SETUP
    23392353#line 267 "lex.ll"
    2340 { KEYWORD_RETURN(VOID); }
    2341         YY_BREAK
    2342 case 99:
     2354{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2355        YY_BREAK
     2356case 102:
    23432357YY_RULE_SETUP
    23442358#line 268 "lex.ll"
    2345 { KEYWORD_RETURN(VOLATILE); }
    2346         YY_BREAK
    2347 case 100:
    2348 YY_RULE_SETUP
    2349 #line 269 "lex.ll"
    2350 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    2351         YY_BREAK
    2352 case 101:
    2353 YY_RULE_SETUP
    2354 #line 270 "lex.ll"
    2355 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    2356         YY_BREAK
    2357 case 102:
    2358 YY_RULE_SETUP
    2359 #line 271 "lex.ll"
    23602359{ KEYWORD_RETURN(WHILE); }
    23612360        YY_BREAK
     
    23632362case 103:
    23642363YY_RULE_SETUP
     2364#line 271 "lex.ll"
     2365{ IDENTIFIER_RETURN(); }
     2366        YY_BREAK
     2367case 104:
     2368YY_RULE_SETUP
     2369#line 272 "lex.ll"
     2370{ ATTRIBUTE_RETURN(); }
     2371        YY_BREAK
     2372case 105:
     2373YY_RULE_SETUP
     2374#line 273 "lex.ll"
     2375{ BEGIN BKQUOTE; }
     2376        YY_BREAK
     2377case 106:
     2378YY_RULE_SETUP
    23652379#line 274 "lex.ll"
    23662380{ IDENTIFIER_RETURN(); }
    23672381        YY_BREAK
    2368 case 104:
     2382case 107:
    23692383YY_RULE_SETUP
    23702384#line 275 "lex.ll"
    2371 { ATTRIBUTE_RETURN(); }
    2372         YY_BREAK
    2373 case 105:
    2374 YY_RULE_SETUP
    2375 #line 276 "lex.ll"
    2376 { BEGIN BKQUOTE; }
    2377         YY_BREAK
    2378 case 106:
    2379 YY_RULE_SETUP
    2380 #line 277 "lex.ll"
    2381 { IDENTIFIER_RETURN(); }
    2382         YY_BREAK
    2383 case 107:
    2384 YY_RULE_SETUP
    2385 #line 278 "lex.ll"
    23862385{ BEGIN 0; }
    23872386        YY_BREAK
     
    23892388case 108:
    23902389YY_RULE_SETUP
     2390#line 278 "lex.ll"
     2391{ NUMERIC_RETURN(ZERO); }                               // CFA
     2392        YY_BREAK
     2393case 109:
     2394YY_RULE_SETUP
     2395#line 279 "lex.ll"
     2396{ NUMERIC_RETURN(ONE); }                                // CFA
     2397        YY_BREAK
     2398case 110:
     2399YY_RULE_SETUP
     2400#line 280 "lex.ll"
     2401{ NUMERIC_RETURN(INTEGERconstant); }
     2402        YY_BREAK
     2403case 111:
     2404YY_RULE_SETUP
    23912405#line 281 "lex.ll"
    2392 { NUMERIC_RETURN(ZERO); }                               // CFA
    2393         YY_BREAK
    2394 case 109:
     2406{ NUMERIC_RETURN(INTEGERconstant); }
     2407        YY_BREAK
     2408case 112:
    23952409YY_RULE_SETUP
    23962410#line 282 "lex.ll"
    2397 { NUMERIC_RETURN(ONE); }                                // CFA
    2398         YY_BREAK
    2399 case 110:
     2411{ NUMERIC_RETURN(INTEGERconstant); }
     2412        YY_BREAK
     2413case 113:
    24002414YY_RULE_SETUP
    24012415#line 283 "lex.ll"
    2402 { NUMERIC_RETURN(INTEGERconstant); }
    2403         YY_BREAK
    2404 case 111:
     2416{ NUMERIC_RETURN(FLOATINGconstant); }
     2417        YY_BREAK
     2418case 114:
    24052419YY_RULE_SETUP
    24062420#line 284 "lex.ll"
    2407 { NUMERIC_RETURN(INTEGERconstant); }
    2408         YY_BREAK
    2409 case 112:
    2410 YY_RULE_SETUP
    2411 #line 285 "lex.ll"
    2412 { NUMERIC_RETURN(INTEGERconstant); }
    2413         YY_BREAK
    2414 case 113:
    2415 YY_RULE_SETUP
    2416 #line 286 "lex.ll"
    2417 { NUMERIC_RETURN(FLOATINGconstant); }
    2418         YY_BREAK
    2419 case 114:
    2420 YY_RULE_SETUP
    2421 #line 287 "lex.ll"
    24222421{ NUMERIC_RETURN(FLOATINGconstant); }
    24232422        YY_BREAK
     
    24252424case 115:
    24262425YY_RULE_SETUP
    2427 #line 290 "lex.ll"
     2426#line 287 "lex.ll"
    24282427{ BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24292428        YY_BREAK
    24302429case 116:
    24312430YY_RULE_SETUP
    2432 #line 291 "lex.ll"
     2431#line 288 "lex.ll"
    24332432{ strtext->append( yytext, yyleng ); }
    24342433        YY_BREAK
     
    24362435/* rule 117 can match eol */
    24372436YY_RULE_SETUP
    2438 #line 292 "lex.ll"
     2437#line 289 "lex.ll"
    24392438{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    24402439        YY_BREAK
     
    24432442case 118:
    24442443YY_RULE_SETUP
    2445 #line 296 "lex.ll"
     2444#line 293 "lex.ll"
    24462445{ BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24472446        YY_BREAK
    24482447case 119:
    24492448YY_RULE_SETUP
    2450 #line 297 "lex.ll"
     2449#line 294 "lex.ll"
    24512450{ strtext->append( yytext, yyleng ); }
    24522451        YY_BREAK
     
    24542453/* rule 120 can match eol */
    24552454YY_RULE_SETUP
    2456 #line 298 "lex.ll"
     2455#line 295 "lex.ll"
    24572456{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    24582457        YY_BREAK
     
    24612460case 121:
    24622461YY_RULE_SETUP
    2463 #line 302 "lex.ll"
     2462#line 299 "lex.ll"
    24642463{ rm_underscore(); strtext->append( yytext, yyleng ); }
    24652464        YY_BREAK
     
    24672466/* rule 122 can match eol */
    24682467YY_RULE_SETUP
    2469 #line 303 "lex.ll"
     2468#line 300 "lex.ll"
    24702469{}                                              // continuation (ALSO HANDLED BY CPP)
    24712470        YY_BREAK
    24722471case 123:
    24732472YY_RULE_SETUP
    2474 #line 304 "lex.ll"
     2473#line 301 "lex.ll"
    24752474{ strtext->append( yytext, yyleng ); } // unknown escape character
    24762475        YY_BREAK
     
    24782477case 124:
    24792478YY_RULE_SETUP
     2479#line 304 "lex.ll"
     2480{ ASCIIOP_RETURN(); }
     2481        YY_BREAK
     2482case 125:
     2483YY_RULE_SETUP
     2484#line 305 "lex.ll"
     2485{ ASCIIOP_RETURN(); }
     2486        YY_BREAK
     2487case 126:
     2488YY_RULE_SETUP
     2489#line 306 "lex.ll"
     2490{ ASCIIOP_RETURN(); }
     2491        YY_BREAK
     2492case 127:
     2493YY_RULE_SETUP
    24802494#line 307 "lex.ll"
    24812495{ ASCIIOP_RETURN(); }
    24822496        YY_BREAK
    2483 case 125:
     2497case 128:
    24842498YY_RULE_SETUP
    24852499#line 308 "lex.ll"
    24862500{ ASCIIOP_RETURN(); }
    24872501        YY_BREAK
    2488 case 126:
     2502case 129:
    24892503YY_RULE_SETUP
    24902504#line 309 "lex.ll"
    24912505{ ASCIIOP_RETURN(); }
    24922506        YY_BREAK
    2493 case 127:
     2507case 130:
    24942508YY_RULE_SETUP
    24952509#line 310 "lex.ll"
    2496 { ASCIIOP_RETURN(); }
    2497         YY_BREAK
    2498 case 128:
     2510{ ASCIIOP_RETURN(); }                                   // also operator
     2511        YY_BREAK
     2512case 131:
    24992513YY_RULE_SETUP
    25002514#line 311 "lex.ll"
    25012515{ ASCIIOP_RETURN(); }
    25022516        YY_BREAK
    2503 case 129:
     2517case 132:
    25042518YY_RULE_SETUP
    25052519#line 312 "lex.ll"
    25062520{ ASCIIOP_RETURN(); }
    25072521        YY_BREAK
    2508 case 130:
     2522case 133:
    25092523YY_RULE_SETUP
    25102524#line 313 "lex.ll"
    25112525{ ASCIIOP_RETURN(); }                                   // also operator
    25122526        YY_BREAK
    2513 case 131:
     2527case 134:
    25142528YY_RULE_SETUP
    25152529#line 314 "lex.ll"
    2516 { ASCIIOP_RETURN(); }
    2517         YY_BREAK
    2518 case 132:
    2519 YY_RULE_SETUP
    2520 #line 315 "lex.ll"
    2521 { ASCIIOP_RETURN(); }
    2522         YY_BREAK
    2523 case 133:
    2524 YY_RULE_SETUP
    2525 #line 316 "lex.ll"
    2526 { ASCIIOP_RETURN(); }                                   // also operator
    2527         YY_BREAK
    2528 case 134:
    2529 YY_RULE_SETUP
    2530 #line 317 "lex.ll"
    25312530{ NAMEDOP_RETURN(ELLIPSIS); }
    25322531        YY_BREAK
     
    25342533case 135:
    25352534YY_RULE_SETUP
     2535#line 317 "lex.ll"
     2536{ RETURN_VAL('['); }
     2537        YY_BREAK
     2538case 136:
     2539YY_RULE_SETUP
     2540#line 318 "lex.ll"
     2541{ RETURN_VAL(']'); }
     2542        YY_BREAK
     2543case 137:
     2544YY_RULE_SETUP
     2545#line 319 "lex.ll"
     2546{ RETURN_VAL('{'); }
     2547        YY_BREAK
     2548case 138:
     2549YY_RULE_SETUP
    25362550#line 320 "lex.ll"
    2537 { RETURN_VAL('['); }
    2538         YY_BREAK
    2539 case 136:
    2540 YY_RULE_SETUP
    2541 #line 321 "lex.ll"
    2542 { RETURN_VAL(']'); }
    2543         YY_BREAK
    2544 case 137:
    2545 YY_RULE_SETUP
    2546 #line 322 "lex.ll"
    2547 { RETURN_VAL('{'); }
    2548         YY_BREAK
    2549 case 138:
    2550 YY_RULE_SETUP
    2551 #line 323 "lex.ll"
    25522551{ RETURN_VAL('}'); }
    25532552        YY_BREAK
     
    25552554case 139:
    25562555YY_RULE_SETUP
     2556#line 323 "lex.ll"
     2557{ ASCIIOP_RETURN(); }
     2558        YY_BREAK
     2559case 140:
     2560YY_RULE_SETUP
     2561#line 324 "lex.ll"
     2562{ ASCIIOP_RETURN(); }
     2563        YY_BREAK
     2564case 141:
     2565YY_RULE_SETUP
     2566#line 325 "lex.ll"
     2567{ ASCIIOP_RETURN(); }
     2568        YY_BREAK
     2569case 142:
     2570YY_RULE_SETUP
    25572571#line 326 "lex.ll"
    25582572{ ASCIIOP_RETURN(); }
    25592573        YY_BREAK
    2560 case 140:
     2574case 143:
    25612575YY_RULE_SETUP
    25622576#line 327 "lex.ll"
    25632577{ ASCIIOP_RETURN(); }
    25642578        YY_BREAK
    2565 case 141:
     2579case 144:
    25662580YY_RULE_SETUP
    25672581#line 328 "lex.ll"
    25682582{ ASCIIOP_RETURN(); }
    25692583        YY_BREAK
    2570 case 142:
     2584case 145:
    25712585YY_RULE_SETUP
    25722586#line 329 "lex.ll"
    25732587{ ASCIIOP_RETURN(); }
    25742588        YY_BREAK
    2575 case 143:
     2589case 146:
    25762590YY_RULE_SETUP
    25772591#line 330 "lex.ll"
    25782592{ ASCIIOP_RETURN(); }
    25792593        YY_BREAK
    2580 case 144:
     2594case 147:
    25812595YY_RULE_SETUP
    25822596#line 331 "lex.ll"
    25832597{ ASCIIOP_RETURN(); }
    25842598        YY_BREAK
    2585 case 145:
     2599case 148:
    25862600YY_RULE_SETUP
    25872601#line 332 "lex.ll"
    25882602{ ASCIIOP_RETURN(); }
    25892603        YY_BREAK
    2590 case 146:
     2604case 149:
    25912605YY_RULE_SETUP
    25922606#line 333 "lex.ll"
    25932607{ ASCIIOP_RETURN(); }
    25942608        YY_BREAK
    2595 case 147:
     2609case 150:
    25962610YY_RULE_SETUP
    25972611#line 334 "lex.ll"
    25982612{ ASCIIOP_RETURN(); }
    25992613        YY_BREAK
    2600 case 148:
     2614case 151:
    26012615YY_RULE_SETUP
    26022616#line 335 "lex.ll"
    26032617{ ASCIIOP_RETURN(); }
    26042618        YY_BREAK
    2605 case 149:
     2619case 152:
    26062620YY_RULE_SETUP
    26072621#line 336 "lex.ll"
    26082622{ ASCIIOP_RETURN(); }
    26092623        YY_BREAK
    2610 case 150:
    2611 YY_RULE_SETUP
    2612 #line 337 "lex.ll"
    2613 { ASCIIOP_RETURN(); }
    2614         YY_BREAK
    2615 case 151:
     2624case 153:
    26162625YY_RULE_SETUP
    26172626#line 338 "lex.ll"
    2618 { ASCIIOP_RETURN(); }
    2619         YY_BREAK
    2620 case 152:
     2627{ NAMEDOP_RETURN(ICR); }
     2628        YY_BREAK
     2629case 154:
    26212630YY_RULE_SETUP
    26222631#line 339 "lex.ll"
    2623 { ASCIIOP_RETURN(); }
    2624         YY_BREAK
    2625 case 153:
     2632{ NAMEDOP_RETURN(DECR); }
     2633        YY_BREAK
     2634case 155:
     2635YY_RULE_SETUP
     2636#line 340 "lex.ll"
     2637{ NAMEDOP_RETURN(EQ); }
     2638        YY_BREAK
     2639case 156:
    26262640YY_RULE_SETUP
    26272641#line 341 "lex.ll"
    2628 { NAMEDOP_RETURN(ICR); }
    2629         YY_BREAK
    2630 case 154:
     2642{ NAMEDOP_RETURN(NE); }
     2643        YY_BREAK
     2644case 157:
    26312645YY_RULE_SETUP
    26322646#line 342 "lex.ll"
    2633 { NAMEDOP_RETURN(DECR); }
    2634         YY_BREAK
    2635 case 155:
     2647{ NAMEDOP_RETURN(LS); }
     2648        YY_BREAK
     2649case 158:
    26362650YY_RULE_SETUP
    26372651#line 343 "lex.ll"
    2638 { NAMEDOP_RETURN(EQ); }
    2639         YY_BREAK
    2640 case 156:
     2652{ NAMEDOP_RETURN(RS); }
     2653        YY_BREAK
     2654case 159:
    26412655YY_RULE_SETUP
    26422656#line 344 "lex.ll"
    2643 { NAMEDOP_RETURN(NE); }
    2644         YY_BREAK
    2645 case 157:
     2657{ NAMEDOP_RETURN(LE); }
     2658        YY_BREAK
     2659case 160:
    26462660YY_RULE_SETUP
    26472661#line 345 "lex.ll"
    2648 { NAMEDOP_RETURN(LS); }
    2649         YY_BREAK
    2650 case 158:
     2662{ NAMEDOP_RETURN(GE); }
     2663        YY_BREAK
     2664case 161:
    26512665YY_RULE_SETUP
    26522666#line 346 "lex.ll"
    2653 { NAMEDOP_RETURN(RS); }
    2654         YY_BREAK
    2655 case 159:
     2667{ NAMEDOP_RETURN(ANDAND); }
     2668        YY_BREAK
     2669case 162:
    26562670YY_RULE_SETUP
    26572671#line 347 "lex.ll"
    2658 { NAMEDOP_RETURN(LE); }
    2659         YY_BREAK
    2660 case 160:
     2672{ NAMEDOP_RETURN(OROR); }
     2673        YY_BREAK
     2674case 163:
    26612675YY_RULE_SETUP
    26622676#line 348 "lex.ll"
    2663 { NAMEDOP_RETURN(GE); }
    2664         YY_BREAK
    2665 case 161:
     2677{ NAMEDOP_RETURN(ARROW); }
     2678        YY_BREAK
     2679case 164:
    26662680YY_RULE_SETUP
    26672681#line 349 "lex.ll"
    2668 { NAMEDOP_RETURN(ANDAND); }
    2669         YY_BREAK
    2670 case 162:
     2682{ NAMEDOP_RETURN(PLUSassign); }
     2683        YY_BREAK
     2684case 165:
    26712685YY_RULE_SETUP
    26722686#line 350 "lex.ll"
    2673 { NAMEDOP_RETURN(OROR); }
    2674         YY_BREAK
    2675 case 163:
     2687{ NAMEDOP_RETURN(MINUSassign); }
     2688        YY_BREAK
     2689case 166:
    26762690YY_RULE_SETUP
    26772691#line 351 "lex.ll"
    2678 { NAMEDOP_RETURN(ARROW); }
    2679         YY_BREAK
    2680 case 164:
     2692{ NAMEDOP_RETURN(MULTassign); }
     2693        YY_BREAK
     2694case 167:
    26812695YY_RULE_SETUP
    26822696#line 352 "lex.ll"
    2683 { NAMEDOP_RETURN(PLUSassign); }
    2684         YY_BREAK
    2685 case 165:
     2697{ NAMEDOP_RETURN(DIVassign); }
     2698        YY_BREAK
     2699case 168:
    26862700YY_RULE_SETUP
    26872701#line 353 "lex.ll"
    2688 { NAMEDOP_RETURN(MINUSassign); }
    2689         YY_BREAK
    2690 case 166:
     2702{ NAMEDOP_RETURN(MODassign); }
     2703        YY_BREAK
     2704case 169:
    26912705YY_RULE_SETUP
    26922706#line 354 "lex.ll"
    2693 { NAMEDOP_RETURN(MULTassign); }
    2694         YY_BREAK
    2695 case 167:
     2707{ NAMEDOP_RETURN(ANDassign); }
     2708        YY_BREAK
     2709case 170:
    26962710YY_RULE_SETUP
    26972711#line 355 "lex.ll"
    2698 { NAMEDOP_RETURN(DIVassign); }
    2699         YY_BREAK
    2700 case 168:
     2712{ NAMEDOP_RETURN(ORassign); }
     2713        YY_BREAK
     2714case 171:
    27012715YY_RULE_SETUP
    27022716#line 356 "lex.ll"
    2703 { NAMEDOP_RETURN(MODassign); }
    2704         YY_BREAK
    2705 case 169:
     2717{ NAMEDOP_RETURN(ERassign); }
     2718        YY_BREAK
     2719case 172:
    27062720YY_RULE_SETUP
    27072721#line 357 "lex.ll"
    2708 { NAMEDOP_RETURN(ANDassign); }
    2709         YY_BREAK
    2710 case 170:
     2722{ NAMEDOP_RETURN(LSassign); }
     2723        YY_BREAK
     2724case 173:
    27112725YY_RULE_SETUP
    27122726#line 358 "lex.ll"
    2713 { NAMEDOP_RETURN(ORassign); }
    2714         YY_BREAK
    2715 case 171:
    2716 YY_RULE_SETUP
    2717 #line 359 "lex.ll"
    2718 { NAMEDOP_RETURN(ERassign); }
    2719         YY_BREAK
    2720 case 172:
     2727{ NAMEDOP_RETURN(RSassign); }
     2728        YY_BREAK
     2729case 174:
    27212730YY_RULE_SETUP
    27222731#line 360 "lex.ll"
    2723 { NAMEDOP_RETURN(LSassign); }
    2724         YY_BREAK
    2725 case 173:
    2726 YY_RULE_SETUP
    2727 #line 361 "lex.ll"
    2728 { NAMEDOP_RETURN(RSassign); }
    2729         YY_BREAK
    2730 case 174:
    2731 YY_RULE_SETUP
    2732 #line 363 "lex.ll"
    27332732{ NAMEDOP_RETURN(ATassign); }                   // CFA
    27342733        YY_BREAK
     
    27362735case 175:
    27372736YY_RULE_SETUP
     2737#line 363 "lex.ll"
     2738{ IDENTIFIER_RETURN(); }                                // unary
     2739        YY_BREAK
     2740case 176:
     2741YY_RULE_SETUP
     2742#line 364 "lex.ll"
     2743{ IDENTIFIER_RETURN(); }
     2744        YY_BREAK
     2745case 177:
     2746YY_RULE_SETUP
     2747#line 365 "lex.ll"
     2748{ IDENTIFIER_RETURN(); }
     2749        YY_BREAK
     2750case 178:
     2751YY_RULE_SETUP
    27382752#line 366 "lex.ll"
    2739 { IDENTIFIER_RETURN(); }                                // unary
    2740         YY_BREAK
    2741 case 176:
    2742 YY_RULE_SETUP
    2743 #line 367 "lex.ll"
    2744 { IDENTIFIER_RETURN(); }
    2745         YY_BREAK
    2746 case 177:
    2747 YY_RULE_SETUP
    2748 #line 368 "lex.ll"
    2749 { IDENTIFIER_RETURN(); }
    2750         YY_BREAK
    2751 case 178:
    2752 YY_RULE_SETUP
    2753 #line 369 "lex.ll"
    27542753{ IDENTIFIER_RETURN(); }                // binary
    27552754        YY_BREAK
     
    27822781case 179:
    27832782YY_RULE_SETUP
    2784 #line 396 "lex.ll"
     2783#line 393 "lex.ll"
    27852784{
    27862785        // 1 or 2 character unary operator ?
     
    27972796case 180:
    27982797YY_RULE_SETUP
    2799 #line 408 "lex.ll"
     2798#line 405 "lex.ll"
    28002799{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    28012800        YY_BREAK
    28022801case 181:
    28032802YY_RULE_SETUP
    2804 #line 410 "lex.ll"
     2803#line 407 "lex.ll"
    28052804ECHO;
    28062805        YY_BREAK
    2807 #line 2808 "Parser/lex.cc"
     2806#line 2807 "Parser/lex.cc"
    28082807case YY_STATE_EOF(INITIAL):
    28092808case YY_STATE_EOF(COMMENT):
     
    37803779#define YYTABLES_NAME "yytables"
    37813780
    3782 #line 410 "lex.ll"
     3781#line 407 "lex.ll"
    37833782
    37843783
  • src/Parser/lex.ll

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

    rf0121d7 ra1e67dd  
    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,   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
     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
    11011101};
    11021102#endif
     
    52025202
    52035203/* Line 1806 of yacc.c  */
    5204 #line 436 "parser.yy"
     5204#line 437 "parser.yy"
    52055205    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
    52065206    break;
     
    52095209
    52105210/* Line 1806 of yacc.c  */
    5211 #line 444 "parser.yy"
     5211#line 445 "parser.yy"
    52125212    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    52135213    break;
     
    52165216
    52175217/* Line 1806 of yacc.c  */
    5218 #line 446 "parser.yy"
     5218#line 447 "parser.yy"
    52195219    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    52205220    break;
     
    52235223
    52245224/* Line 1806 of yacc.c  */
    5225 #line 448 "parser.yy"
     5225#line 449 "parser.yy"
    52265226    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    52275227    break;
     
    52305230
    52315231/* Line 1806 of yacc.c  */
    5232 #line 453 "parser.yy"
     5232#line 454 "parser.yy"
    52335233    {
    52345234                        switch ( (yyvsp[(1) - (2)].op) ) {
     
    52485248
    52495249/* Line 1806 of yacc.c  */
    5250 #line 466 "parser.yy"
     5250#line 467 "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 468 "parser.yy"
     5257#line 469 "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 470 "parser.yy"
     5264#line 471 "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 472 "parser.yy"
     5271#line 473 "parser.yy"
    52725272    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52735273    break;
     
    52765276
    52775277/* Line 1806 of yacc.c  */
    5278 #line 474 "parser.yy"
     5278#line 475 "parser.yy"
    52795279    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52805280    break;
     
    52835283
    52845284/* Line 1806 of yacc.c  */
    5285 #line 476 "parser.yy"
     5285#line 477 "parser.yy"
    52865286    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52875287    break;
     
    52905290
    52915291/* Line 1806 of yacc.c  */
    5292 #line 478 "parser.yy"
     5292#line 479 "parser.yy"
    52935293    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52945294    break;
     
    52975297
    52985298/* Line 1806 of yacc.c  */
    5299 #line 480 "parser.yy"
     5299#line 481 "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 482 "parser.yy"
     5306#line 483 "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 484 "parser.yy"
     5313#line 485 "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 486 "parser.yy"
     5320#line 487 "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"
     5327#line 493 "parser.yy"
    53285328    { (yyval.op) = OperKinds::PointTo; }
    53295329    break;
     
    53325332
    53335333/* Line 1806 of yacc.c  */
    5334 #line 493 "parser.yy"
     5334#line 494 "parser.yy"
    53355335    { (yyval.op) = OperKinds::AddressOf; }
    53365336    break;
     
    53395339
    53405340/* Line 1806 of yacc.c  */
    5341 #line 499 "parser.yy"
     5341#line 500 "parser.yy"
    53425342    { (yyval.op) = OperKinds::UnPlus; }
    53435343    break;
     
    53465346
    53475347/* Line 1806 of yacc.c  */
    5348 #line 500 "parser.yy"
     5348#line 501 "parser.yy"
    53495349    { (yyval.op) = OperKinds::UnMinus; }
    53505350    break;
     
    53535353
    53545354/* Line 1806 of yacc.c  */
    5355 #line 501 "parser.yy"
     5355#line 502 "parser.yy"
    53565356    { (yyval.op) = OperKinds::Neg; }
    53575357    break;
     
    53605360
    53615361/* Line 1806 of yacc.c  */
    5362 #line 502 "parser.yy"
     5362#line 503 "parser.yy"
    53635363    { (yyval.op) = OperKinds::BitNeg; }
    53645364    break;
     
    53675367
    53685368/* Line 1806 of yacc.c  */
    5369 #line 508 "parser.yy"
     5369#line 509 "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 510 "parser.yy"
     5376#line 511 "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 516 "parser.yy"
     5383#line 517 "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 518 "parser.yy"
     5390#line 519 "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 520 "parser.yy"
     5397#line 521 "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 526 "parser.yy"
     5404#line 527 "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 528 "parser.yy"
     5411#line 529 "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 534 "parser.yy"
     5418#line 535 "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 536 "parser.yy"
     5425#line 537 "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 542 "parser.yy"
     5432#line 543 "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 544 "parser.yy"
     5439#line 545 "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 546 "parser.yy"
     5446#line 547 "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 548 "parser.yy"
     5453#line 549 "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 554 "parser.yy"
     5460#line 555 "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 556 "parser.yy"
     5467#line 557 "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 562 "parser.yy"
     5474#line 563 "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 568 "parser.yy"
     5481#line 569 "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 574 "parser.yy"
     5488#line 575 "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 580 "parser.yy"
     5495#line 581 "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 586 "parser.yy"
     5502#line 587 "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 592 "parser.yy"
     5509#line 593 "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 595 "parser.yy"
     5516#line 596 "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 597 "parser.yy"
     5523#line 598 "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 608 "parser.yy"
     5530#line 609 "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 610 "parser.yy"
     5537#line 611 "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 615 "parser.yy"
     5544#line 616 "parser.yy"
    55455545    { (yyval.en) = nullptr; }
    55465546    break;
     
    55495549
    55505550/* Line 1806 of yacc.c  */
    5551 #line 620 "parser.yy"
     5551#line 621 "parser.yy"
    55525552    { (yyval.op) = OperKinds::Assign; }
    55535553    break;
     
    55565556
    55575557/* Line 1806 of yacc.c  */
    5558 #line 621 "parser.yy"
     5558#line 622 "parser.yy"
    55595559    { (yyval.op) = OperKinds::AtAssn; }
    55605560    break;
     
    55635563
    55645564/* Line 1806 of yacc.c  */
    5565 #line 622 "parser.yy"
     5565#line 623 "parser.yy"
    55665566    { (yyval.op) = OperKinds::MulAssn; }
    55675567    break;
     
    55705570
    55715571/* Line 1806 of yacc.c  */
    5572 #line 623 "parser.yy"
     5572#line 624 "parser.yy"
    55735573    { (yyval.op) = OperKinds::DivAssn; }
    55745574    break;
     
    55775577
    55785578/* Line 1806 of yacc.c  */
    5579 #line 624 "parser.yy"
     5579#line 625 "parser.yy"
    55805580    { (yyval.op) = OperKinds::ModAssn; }
    55815581    break;
     
    55845584
    55855585/* Line 1806 of yacc.c  */
    5586 #line 625 "parser.yy"
     5586#line 626 "parser.yy"
    55875587    { (yyval.op) = OperKinds::PlusAssn; }
    55885588    break;
     
    55915591
    55925592/* Line 1806 of yacc.c  */
    5593 #line 626 "parser.yy"
     5593#line 627 "parser.yy"
    55945594    { (yyval.op) = OperKinds::MinusAssn; }
    55955595    break;
     
    55985598
    55995599/* Line 1806 of yacc.c  */
    5600 #line 627 "parser.yy"
     5600#line 628 "parser.yy"
    56015601    { (yyval.op) = OperKinds::LSAssn; }
    56025602    break;
     
    56055605
    56065606/* Line 1806 of yacc.c  */
    5607 #line 628 "parser.yy"
     5607#line 629 "parser.yy"
    56085608    { (yyval.op) = OperKinds::RSAssn; }
    56095609    break;
     
    56125612
    56135613/* Line 1806 of yacc.c  */
    5614 #line 629 "parser.yy"
     5614#line 630 "parser.yy"
    56155615    { (yyval.op) = OperKinds::AndAssn; }
    56165616    break;
     
    56195619
    56205620/* Line 1806 of yacc.c  */
    5621 #line 630 "parser.yy"
     5621#line 631 "parser.yy"
    56225622    { (yyval.op) = OperKinds::ERAssn; }
    56235623    break;
     
    56265626
    56275627/* Line 1806 of yacc.c  */
    5628 #line 631 "parser.yy"
     5628#line 632 "parser.yy"
    56295629    { (yyval.op) = OperKinds::OrAssn; }
    56305630    break;
     
    56335633
    56345634/* Line 1806 of yacc.c  */
    5635 #line 638 "parser.yy"
     5635#line 639 "parser.yy"
    56365636    { (yyval.en) = new ExpressionNode( build_tuple() ); }
    56375637    break;
     
    56405640
    56415641/* Line 1806 of yacc.c  */
    5642 #line 640 "parser.yy"
     5642#line 641 "parser.yy"
    56435643    { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    56445644    break;
     
    56475647
    56485648/* Line 1806 of yacc.c  */
    5649 #line 642 "parser.yy"
     5649#line 643 "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 644 "parser.yy"
     5656#line 645 "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 650 "parser.yy"
     5663#line 651 "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 656 "parser.yy"
     5670#line 657 "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 661 "parser.yy"
     5677#line 662 "parser.yy"
    56785678    { (yyval.en) = 0; }
    56795679    break;
     
    56825682
    56835683/* Line 1806 of yacc.c  */
    5684 #line 670 "parser.yy"
     5684#line 671 "parser.yy"
    56855685    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56865686    break;
     
    56895689
    56905690/* Line 1806 of yacc.c  */
    5691 #line 677 "parser.yy"
     5691#line 678 "parser.yy"
    56925692    {
    56935693                        Token fn;
     
    57005700
    57015701/* Line 1806 of yacc.c  */
    5702 #line 687 "parser.yy"
     5702#line 688 "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 694 "parser.yy"
     5711#line 695 "parser.yy"
    57125712    { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
    57135713    break;
     
    57165716
    57175717/* Line 1806 of yacc.c  */
    5718 #line 701 "parser.yy"
     5718#line 702 "parser.yy"
    57195719    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
    57205720    break;
     
    57235723
    57245724/* Line 1806 of yacc.c  */
    5725 #line 707 "parser.yy"
     5725#line 708 "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 712 "parser.yy"
     5732#line 713 "parser.yy"
    57335733    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57345734    break;
     
    57375737
    57385738/* Line 1806 of yacc.c  */
    5739 #line 714 "parser.yy"
     5739#line 715 "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 720 "parser.yy"
     5750#line 721 "parser.yy"
    57515751    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57525752    break;
     
    57555755
    57565756/* Line 1806 of yacc.c  */
    5757 #line 727 "parser.yy"
     5757#line 728 "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 732 "parser.yy"
     5764#line 733 "parser.yy"
    57655765    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
    57665766    break;
     
    57695769
    57705770/* Line 1806 of yacc.c  */
    5771 #line 738 "parser.yy"
     5771#line 739 "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 740 "parser.yy"
     5778#line 741 "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 742 "parser.yy"
     5785#line 743 "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 744 "parser.yy"
     5792#line 745 "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 754 "parser.yy"
     5807#line 755 "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 756 "parser.yy"
     5814#line 757 "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 766 "parser.yy"
     5824#line 767 "parser.yy"
    58255825    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    58265826    break;
     
    58295829
    58305830/* Line 1806 of yacc.c  */
    5831 #line 768 "parser.yy"
     5831#line 769 "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 773 "parser.yy"
     5838#line 774 "parser.yy"
    58395839    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
    58405840    break;
     
    58435843
    58445844/* Line 1806 of yacc.c  */
    5845 #line 775 "parser.yy"
     5845#line 776 "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"
     5852#line 780 "parser.yy"
    58535853    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    58545854    break;
     
    58575857
    58585858/* Line 1806 of yacc.c  */
    5859 #line 780 "parser.yy"
     5859#line 781 "parser.yy"
    58605860    { (yyval.sn) = new StatementNode( build_default() ); }
    58615861    break;
     
    58645864
    58655865/* Line 1806 of yacc.c  */
    5866 #line 786 "parser.yy"
     5866#line 787 "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 790 "parser.yy"
     5873#line 791 "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 795 "parser.yy"
     5880#line 796 "parser.yy"
    58815881    { (yyval.sn) = 0; }
    58825882    break;
     
    58855885
    58865886/* Line 1806 of yacc.c  */
    5887 #line 801 "parser.yy"
     5887#line 802 "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 803 "parser.yy"
     5894#line 804 "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 808 "parser.yy"
     5901#line 809 "parser.yy"
    59025902    { (yyval.sn) = 0; }
    59035903    break;
     
    59065906
    59075907/* Line 1806 of yacc.c  */
    5908 #line 814 "parser.yy"
     5908#line 815 "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 816 "parser.yy"
     5915#line 817 "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 818 "parser.yy"
     5922#line 819 "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 820 "parser.yy"
     5929#line 821 "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 825 "parser.yy"
     5936#line 826 "parser.yy"
    59375937    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    59385938    break;
     
    59415941
    59425942/* Line 1806 of yacc.c  */
    5943 #line 831 "parser.yy"
     5943#line 832 "parser.yy"
    59445944    { (yyval.sn) = 0; }
    59455945    break;
     
    59485948
    59495949/* Line 1806 of yacc.c  */
    5950 #line 833 "parser.yy"
     5950#line 834 "parser.yy"
    59515951    { (yyval.sn) = 0; }
    59525952    break;
     
    59555955
    59565956/* Line 1806 of yacc.c  */
    5957 #line 838 "parser.yy"
     5957#line 839 "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 840 "parser.yy"
     5964#line 841 "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 842 "parser.yy"
     5971#line 843 "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 847 "parser.yy"
     5978#line 848 "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 849 "parser.yy"
     5985#line 850 "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 854 "parser.yy"
     5992#line 855 "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 858 "parser.yy"
     5999#line 859 "parser.yy"
    60006000    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
    60016001    break;
     
    60046004
    60056005/* Line 1806 of yacc.c  */
    6006 #line 861 "parser.yy"
     6006#line 862 "parser.yy"
    60076007    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
    60086008    break;
     
    60116011
    60126012/* Line 1806 of yacc.c  */
    6013 #line 865 "parser.yy"
     6013#line 866 "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 868 "parser.yy"
     6020#line 869 "parser.yy"
    60216021    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    60226022    break;
     
    60256025
    60266026/* Line 1806 of yacc.c  */
    6027 #line 872 "parser.yy"
     6027#line 873 "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 874 "parser.yy"
     6034#line 875 "parser.yy"
    60356035    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
    60366036    break;
     
    60396039
    60406040/* Line 1806 of yacc.c  */
    6041 #line 876 "parser.yy"
     6041#line 877 "parser.yy"
    60426042    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    60436043    break;
     
    60466046
    60476047/* Line 1806 of yacc.c  */
    6048 #line 878 "parser.yy"
     6048#line 879 "parser.yy"
    60496049    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    60506050    break;
     
    60536053
    60546054/* Line 1806 of yacc.c  */
    6055 #line 880 "parser.yy"
     6055#line 881 "parser.yy"
    60566056    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
    60576057    break;
     
    60606060
    60616061/* Line 1806 of yacc.c  */
    6062 #line 885 "parser.yy"
     6062#line 886 "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 887 "parser.yy"
     6069#line 888 "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 889 "parser.yy"
     6076#line 890 "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 896 "parser.yy"
     6083#line 897 "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 898 "parser.yy"
     6090#line 899 "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 900 "parser.yy"
     6097#line 901 "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 902 "parser.yy"
     6104#line 903 "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 907 "parser.yy"
     6111#line 908 "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 909 "parser.yy"
     6118#line 910 "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 911 "parser.yy"
     6125#line 912 "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 913 "parser.yy"
     6132#line 914 "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 918 "parser.yy"
     6139#line 919 "parser.yy"
    61406140    {
    61416141                        (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
     
    61466146
    61476147/* Line 1806 of yacc.c  */
    6148 #line 931 "parser.yy"
     6148#line 932 "parser.yy"
    61496149    {
    61506150                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61566156
    61576157/* Line 1806 of yacc.c  */
    6158 #line 936 "parser.yy"
     6158#line 937 "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 938 "parser.yy"
     6165#line 939 "parser.yy"
    61666166    {
    61676167                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61736173
    61746174/* Line 1806 of yacc.c  */
    6175 #line 947 "parser.yy"
     6175#line 948 "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 949 "parser.yy"
     6182#line 950 "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 951 "parser.yy"
     6189#line 952 "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 953 "parser.yy"
     6196#line 954 "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 955 "parser.yy"
     6203#line 956 "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 960 "parser.yy"
     6210#line 961 "parser.yy"
    62116211    { (yyval.flag) = false; }
    62126212    break;
     
    62156215
    62166216/* Line 1806 of yacc.c  */
    6217 #line 962 "parser.yy"
     6217#line 963 "parser.yy"
    62186218    { (yyval.flag) = true; }
    62196219    break;
     
    62226222
    62236223/* Line 1806 of yacc.c  */
    6224 #line 967 "parser.yy"
     6224#line 968 "parser.yy"
    62256225    { (yyval.en) = 0; }
    62266226    break;
     
    62296229
    62306230/* Line 1806 of yacc.c  */
    6231 #line 974 "parser.yy"
     6231#line 975 "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 979 "parser.yy"
     6238#line 980 "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 981 "parser.yy"
     6245#line 982 "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 986 "parser.yy"
     6252#line 987 "parser.yy"
    62536253    { (yyval.en) = 0; }
    62546254    break;
     
    62576257
    62586258/* Line 1806 of yacc.c  */
    6259 #line 988 "parser.yy"
     6259#line 989 "parser.yy"
    62606260    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    62616261    break;
     
    62646264
    62656265/* Line 1806 of yacc.c  */
    6266 #line 990 "parser.yy"
     6266#line 991 "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 995 "parser.yy"
     6273#line 996 "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 1000 "parser.yy"
     6283#line 1001 "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 1010 "parser.yy"
     6293#line 1011 "parser.yy"
    62946294    { (yyval.decl) = 0; }
    62956295    break;
     
    62986298
    62996299/* Line 1806 of yacc.c  */
    6300 #line 1017 "parser.yy"
     6300#line 1018 "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 1022 "parser.yy"
     6307#line 1023 "parser.yy"
    63086308    { (yyval.decl) = 0; }
    63096309    break;
     
    63126312
    63136313/* Line 1806 of yacc.c  */
    6314 #line 1029 "parser.yy"
     6314#line 1030 "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:
    63266319
    63276320/* Line 1806 of yacc.c  */
     
    63306323    break;
    63316324
     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 1073 "parser.yy"
     6335#line 1074 "parser.yy"
    63366336    {
    63376337                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63436343
    63446344/* Line 1806 of yacc.c  */
    6345 #line 1080 "parser.yy"
     6345#line 1081 "parser.yy"
    63466346    {
    63476347                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63536353
    63546354/* Line 1806 of yacc.c  */
    6355 #line 1085 "parser.yy"
     6355#line 1086 "parser.yy"
    63566356    {
    63576357                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    63636363
    63646364/* Line 1806 of yacc.c  */
    6365 #line 1095 "parser.yy"
     6365#line 1096 "parser.yy"
    63666366    {
    63676367                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63736373
    63746374/* Line 1806 of yacc.c  */
    6375 #line 1100 "parser.yy"
     6375#line 1101 "parser.yy"
    63766376    {
    63776377                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63836383
    63846384/* Line 1806 of yacc.c  */
    6385 #line 1105 "parser.yy"
     6385#line 1106 "parser.yy"
    63866386    {
    63876387                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    63936393
    63946394/* Line 1806 of yacc.c  */
    6395 #line 1113 "parser.yy"
     6395#line 1114 "parser.yy"
    63966396    {
    63976397                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64036403
    64046404/* Line 1806 of yacc.c  */
    6405 #line 1118 "parser.yy"
     6405#line 1119 "parser.yy"
    64066406    {
    64076407                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64136413
    64146414/* Line 1806 of yacc.c  */
    6415 #line 1123 "parser.yy"
     6415#line 1124 "parser.yy"
    64166416    {
    64176417                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64236423
    64246424/* Line 1806 of yacc.c  */
    6425 #line 1128 "parser.yy"
     6425#line 1129 "parser.yy"
    64266426    {
    64276427                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64336433
    64346434/* Line 1806 of yacc.c  */
    6435 #line 1133 "parser.yy"
     6435#line 1134 "parser.yy"
    64366436    {
    64376437                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    64436443
    64446444/* Line 1806 of yacc.c  */
    6445 #line 1141 "parser.yy"
     6445#line 1142 "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 1164 "parser.yy"
     6454#line 1165 "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 1168 "parser.yy"
     6463#line 1169 "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 1175 "parser.yy"
     6472#line 1176 "parser.yy"
    64736473    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64746474    break;
     
    64776477
    64786478/* Line 1806 of yacc.c  */
    6479 #line 1179 "parser.yy"
     6479#line 1180 "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 1184 "parser.yy"
     6486#line 1185 "parser.yy"
    64876487    {
    64886488                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64946494
    64956495/* Line 1806 of yacc.c  */
    6496 #line 1189 "parser.yy"
     6496#line 1190 "parser.yy"
    64976497    {
    64986498                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65046504
    65056505/* Line 1806 of yacc.c  */
    6506 #line 1194 "parser.yy"
     6506#line 1195 "parser.yy"
    65076507    {
    65086508                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    65146514
    65156515/* Line 1806 of yacc.c  */
    6516 #line 1205 "parser.yy"
     6516#line 1206 "parser.yy"
    65176517    {
    65186518                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65246524
    65256525/* Line 1806 of yacc.c  */
    6526 #line 1210 "parser.yy"
     6526#line 1211 "parser.yy"
    65276527    {
    65286528                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65346534
    65356535/* Line 1806 of yacc.c  */
    6536 #line 1215 "parser.yy"
     6536#line 1216 "parser.yy"
    65376537    {
    65386538                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65446544
    65456545/* Line 1806 of yacc.c  */
    6546 #line 1220 "parser.yy"
     6546#line 1221 "parser.yy"
    65476547    {
    65486548                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65546554
    65556555/* Line 1806 of yacc.c  */
    6556 #line 1225 "parser.yy"
     6556#line 1226 "parser.yy"
    65576557    {
    65586558                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65646564
    65656565/* Line 1806 of yacc.c  */
    6566 #line 1234 "parser.yy"
     6566#line 1235 "parser.yy"
    65676567    {
    65686568                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    65746574
    65756575/* Line 1806 of yacc.c  */
    6576 #line 1239 "parser.yy"
     6576#line 1240 "parser.yy"
    65776577    {
    65786578                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    65846584
    65856585/* Line 1806 of yacc.c  */
    6586 #line 1256 "parser.yy"
     6586#line 1257 "parser.yy"
    65876587    {
    65886588                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65946594
    65956595/* Line 1806 of yacc.c  */
    6596 #line 1261 "parser.yy"
     6596#line 1262 "parser.yy"
    65976597    {
    65986598                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66046604
    66056605/* Line 1806 of yacc.c  */
    6606 #line 1283 "parser.yy"
     6606#line 1284 "parser.yy"
    66076607    { (yyval.decl) = 0; }
    66086608    break;
     
    66116611
    66126612/* Line 1806 of yacc.c  */
    6613 #line 1295 "parser.yy"
     6613#line 1296 "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 1306 "parser.yy"
     6620#line 1307 "parser.yy"
    66216621    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    66226622    break;
     
    66256625
    66266626/* Line 1806 of yacc.c  */
    6627 #line 1308 "parser.yy"
     6627#line 1309 "parser.yy"
    66286628    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    66296629    break;
     
    66326632
    66336633/* Line 1806 of yacc.c  */
    6634 #line 1310 "parser.yy"
     6634#line 1311 "parser.yy"
    66356635    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    66366636    break;
     
    66396639
    66406640/* Line 1806 of yacc.c  */
    6641 #line 1312 "parser.yy"
     6641#line 1313 "parser.yy"
    66426642    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    66436643    break;
     
    66466646
    66476647/* Line 1806 of yacc.c  */
    6648 #line 1314 "parser.yy"
     6648#line 1315 "parser.yy"
    66496649    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    66506650    break;
     
    66536653
    66546654/* Line 1806 of yacc.c  */
    6655 #line 1316 "parser.yy"
     6655#line 1317 "parser.yy"
    66566656    {
    66576657                        typedefTable.enterScope();
     
    66626662
    66636663/* Line 1806 of yacc.c  */
    6664 #line 1320 "parser.yy"
     6664#line 1321 "parser.yy"
    66656665    {
    66666666                        typedefTable.leaveScope();
     
    66726672
    66736673/* Line 1806 of yacc.c  */
    6674 #line 1329 "parser.yy"
     6674#line 1330 "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 1331 "parser.yy"
     6681#line 1332 "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 1342 "parser.yy"
     6688#line 1343 "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 1347 "parser.yy"
     6695#line 1348 "parser.yy"
    66966696    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    66976697    break;
     
    67006700
    67016701/* Line 1806 of yacc.c  */
    6702 #line 1349 "parser.yy"
     6702#line 1350 "parser.yy"
    67036703    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    67046704    break;
     
    67076707
    67086708/* Line 1806 of yacc.c  */
    6709 #line 1351 "parser.yy"
     6709#line 1352 "parser.yy"
    67106710    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    67116711    break;
     
    67146714
    67156715/* Line 1806 of yacc.c  */
    6716 #line 1353 "parser.yy"
     6716#line 1354 "parser.yy"
    67176717    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    67186718    break;
     
    67216721
    67226722/* Line 1806 of yacc.c  */
    6723 #line 1356 "parser.yy"
     6723#line 1357 "parser.yy"
    67246724    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
    67256725    break;
     
    67286728
    67296729/* Line 1806 of yacc.c  */
    6730 #line 1358 "parser.yy"
     6730#line 1359 "parser.yy"
    67316731    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    67326732    break;
     
    67356735
    67366736/* Line 1806 of yacc.c  */
    6737 #line 1361 "parser.yy"
     6737#line 1362 "parser.yy"
    67386738    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
    67396739    break;
     
    67426742
    67436743/* Line 1806 of yacc.c  */
    6744 #line 1363 "parser.yy"
     6744#line 1364 "parser.yy"
    67456745    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    67466746    break;
     
    67496749
    67506750/* Line 1806 of yacc.c  */
    6751 #line 1368 "parser.yy"
     6751#line 1369 "parser.yy"
    67526752    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    67536753    break;
     
    67566756
    67576757/* Line 1806 of yacc.c  */
    6758 #line 1370 "parser.yy"
     6758#line 1371 "parser.yy"
    67596759    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    67606760    break;
     
    67636763
    67646764/* Line 1806 of yacc.c  */
    6765 #line 1372 "parser.yy"
     6765#line 1373 "parser.yy"
    67666766    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    67676767    break;
     
    67706770
    67716771/* Line 1806 of yacc.c  */
    6772 #line 1374 "parser.yy"
     6772#line 1375 "parser.yy"
    67736773    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    67746774    break;
     
    67776777
    67786778/* Line 1806 of yacc.c  */
    6779 #line 1376 "parser.yy"
     6779#line 1377 "parser.yy"
    67806780    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
    67816781    break;
     
    67846784
    67856785/* Line 1806 of yacc.c  */
    6786 #line 1378 "parser.yy"
     6786#line 1379 "parser.yy"
    67876787    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
    67886788    break;
     
    67916791
    67926792/* Line 1806 of yacc.c  */
    6793 #line 1380 "parser.yy"
     6793#line 1381 "parser.yy"
    67946794    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
    67956795    break;
     
    67986798
    67996799/* Line 1806 of yacc.c  */
    6800 #line 1382 "parser.yy"
     6800#line 1383 "parser.yy"
    68016801    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
    68026802    break;
     
    68056805
    68066806/* Line 1806 of yacc.c  */
    6807 #line 1384 "parser.yy"
     6807#line 1385 "parser.yy"
    68086808    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    68096809    break;
     
    68126812
    68136813/* Line 1806 of yacc.c  */
    6814 #line 1386 "parser.yy"
     6814#line 1387 "parser.yy"
    68156815    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    68166816    break;
     
    68196819
    68206820/* Line 1806 of yacc.c  */
    6821 #line 1388 "parser.yy"
     6821#line 1389 "parser.yy"
    68226822    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
    68236823    break;
     
    68266826
    68276827/* Line 1806 of yacc.c  */
    6828 #line 1390 "parser.yy"
     6828#line 1391 "parser.yy"
    68296829    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
    68306830    break;
     
    68336833
    68346834/* Line 1806 of yacc.c  */
    6835 #line 1392 "parser.yy"
     6835#line 1393 "parser.yy"
    68366836    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    68376837    break;
     
    68406840
    68416841/* Line 1806 of yacc.c  */
    6842 #line 1399 "parser.yy"
     6842#line 1400 "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 1401 "parser.yy"
     6849#line 1402 "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 1403 "parser.yy"
     6856#line 1404 "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 1405 "parser.yy"
     6863#line 1406 "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 1411 "parser.yy"
     6870#line 1412 "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 1418 "parser.yy"
     6877#line 1419 "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 1420 "parser.yy"
     6884#line 1421 "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 1422 "parser.yy"
     6891#line 1423 "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 1427 "parser.yy"
     6898#line 1428 "parser.yy"
    68996899    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    69006900    break;
     
    69036903
    69046904/* Line 1806 of yacc.c  */
    6905 #line 1429 "parser.yy"
     6905#line 1430 "parser.yy"
    69066906    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    69076907    break;
     
    69106910
    69116911/* Line 1806 of yacc.c  */
    6912 #line 1431 "parser.yy"
     6912#line 1432 "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 1433 "parser.yy"
     6919#line 1434 "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 1439 "parser.yy"
     6926#line 1440 "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 1441 "parser.yy"
     6933#line 1442 "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 1443 "parser.yy"
     6940#line 1444 "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 1449 "parser.yy"
     6947#line 1450 "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 1451 "parser.yy"
     6954#line 1452 "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 1457 "parser.yy"
     6961#line 1458 "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 1459 "parser.yy"
     6968#line 1460 "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 1461 "parser.yy"
     6975#line 1462 "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 1466 "parser.yy"
     6982#line 1467 "parser.yy"
    69836983    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    69846984    break;
     
    69876987
    69886988/* Line 1806 of yacc.c  */
    6989 #line 1468 "parser.yy"
     6989#line 1469 "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 1470 "parser.yy"
     6996#line 1471 "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 1480 "parser.yy"
     7003#line 1481 "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 1482 "parser.yy"
     7010#line 1483 "parser.yy"
    70117011    {
    70127012                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    70187018
    70197019/* Line 1806 of yacc.c  */
    7020 #line 1487 "parser.yy"
     7020#line 1488 "parser.yy"
    70217021    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70227022    break;
     
    70257025
    70267026/* Line 1806 of yacc.c  */
    7027 #line 1489 "parser.yy"
     7027#line 1490 "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 1491 "parser.yy"
     7034#line 1492 "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 1493 "parser.yy"
     7041#line 1494 "parser.yy"
    70427042    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    70437043    break;
     
    70467046
    70477047/* Line 1806 of yacc.c  */
    7048 #line 1498 "parser.yy"
     7048#line 1499 "parser.yy"
    70497049    { (yyval.aggKey) = DeclarationNode::Struct; }
    70507050    break;
     
    70537053
    70547054/* Line 1806 of yacc.c  */
    7055 #line 1500 "parser.yy"
     7055#line 1501 "parser.yy"
    70567056    { (yyval.aggKey) = DeclarationNode::Union; }
    70577057    break;
     
    70607060
    70617061/* Line 1806 of yacc.c  */
    7062 #line 1505 "parser.yy"
     7062#line 1506 "parser.yy"
    70637063    { (yyval.decl) = 0; }
    70647064    break;
     
    70677067
    70687068/* Line 1806 of yacc.c  */
    7069 #line 1507 "parser.yy"
     7069#line 1508 "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 1513 "parser.yy"
     7076#line 1514 "parser.yy"
    70777077    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70787078    break;
     
    70817081
    70827082/* Line 1806 of yacc.c  */
    7083 #line 1516 "parser.yy"
     7083#line 1517 "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 1526 "parser.yy"
     7094#line 1527 "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 1528 "parser.yy"
     7101#line 1529 "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 1530 "parser.yy"
     7108#line 1531 "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 1535 "parser.yy"
     7115#line 1536 "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 1537 "parser.yy"
     7122#line 1538 "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 1542 "parser.yy"
     7129#line 1543 "parser.yy"
    71307130    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    71317131    break;
     
    71347134
    71357135/* Line 1806 of yacc.c  */
    7136 #line 1544 "parser.yy"
     7136#line 1545 "parser.yy"
    71377137    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    71387138    break;
     
    71417141
    71427142/* Line 1806 of yacc.c  */
    7143 #line 1547 "parser.yy"
     7143#line 1548 "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 1550 "parser.yy"
     7150#line 1551 "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 1556 "parser.yy"
     7157#line 1557 "parser.yy"
    71587158    { (yyval.en) = 0; }
    71597159    break;
     
    71627162
    71637163/* Line 1806 of yacc.c  */
    7164 #line 1558 "parser.yy"
     7164#line 1559 "parser.yy"
    71657165    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71667166    break;
     
    71697169
    71707170/* Line 1806 of yacc.c  */
    7171 #line 1563 "parser.yy"
     7171#line 1564 "parser.yy"
    71727172    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71737173    break;
     
    71767176
    71777177/* Line 1806 of yacc.c  */
    7178 #line 1572 "parser.yy"
     7178#line 1573 "parser.yy"
    71797179    { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
    71807180    break;
     
    71837183
    71847184/* Line 1806 of yacc.c  */
    7185 #line 1574 "parser.yy"
     7185#line 1575 "parser.yy"
    71867186    {
    71877187                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    71937193
    71947194/* Line 1806 of yacc.c  */
    7195 #line 1579 "parser.yy"
     7195#line 1580 "parser.yy"
    71967196    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71977197    break;
     
    72007200
    72017201/* Line 1806 of yacc.c  */
    7202 #line 1581 "parser.yy"
     7202#line 1582 "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 1586 "parser.yy"
     7209#line 1587 "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 1588 "parser.yy"
     7216#line 1589 "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 1593 "parser.yy"
     7223#line 1594 "parser.yy"
    72247224    { (yyval.en) = 0; }
    72257225    break;
     
    72287228
    72297229/* Line 1806 of yacc.c  */
    7230 #line 1595 "parser.yy"
     7230#line 1596 "parser.yy"
    72317231    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    72327232    break;
     
    72357235
    72367236/* Line 1806 of yacc.c  */
    7237 #line 1602 "parser.yy"
     7237#line 1603 "parser.yy"
    72387238    { (yyval.decl) = 0; }
    72397239    break;
     
    72427242
    72437243/* Line 1806 of yacc.c  */
    7244 #line 1610 "parser.yy"
     7244#line 1611 "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 1612 "parser.yy"
     7251#line 1613 "parser.yy"
    72527252    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72537253    break;
     
    72567256
    72577257/* Line 1806 of yacc.c  */
    7258 #line 1614 "parser.yy"
     7258#line 1615 "parser.yy"
    72597259    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72607260    break;
     
    72637263
    72647264/* Line 1806 of yacc.c  */
    7265 #line 1622 "parser.yy"
     7265#line 1623 "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 1624 "parser.yy"
     7272#line 1625 "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 1626 "parser.yy"
     7279#line 1627 "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 1632 "parser.yy"
     7286#line 1633 "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 1637 "parser.yy"
     7293#line 1638 "parser.yy"
    72947294    { (yyval.decl) = 0; }
    72957295    break;
     
    72987298
    72997299/* Line 1806 of yacc.c  */
    7300 #line 1644 "parser.yy"
     7300#line 1645 "parser.yy"
    73017301    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    73027302    break;
     
    73057305
    73067306/* Line 1806 of yacc.c  */
    7307 #line 1651 "parser.yy"
     7307#line 1652 "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 1653 "parser.yy"
     7314#line 1654 "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 1662 "parser.yy"
     7321#line 1663 "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 1665 "parser.yy"
     7328#line 1666 "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 1667 "parser.yy"
     7335#line 1668 "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 1677 "parser.yy"
     7342#line 1678 "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 1683 "parser.yy"
     7349#line 1684 "parser.yy"
    73507350    {
    73517351                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73577357
    73587358/* Line 1806 of yacc.c  */
    7359 #line 1688 "parser.yy"
     7359#line 1689 "parser.yy"
    73607360    {
    73617361                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73677367
    73687368/* Line 1806 of yacc.c  */
    7369 #line 1697 "parser.yy"
     7369#line 1698 "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 1706 "parser.yy"
     7376#line 1707 "parser.yy"
    73777377    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73787378    break;
     
    73817381
    73827382/* Line 1806 of yacc.c  */
    7383 #line 1708 "parser.yy"
     7383#line 1709 "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 1733 "parser.yy"
     7390#line 1734 "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 1741 "parser.yy"
     7397#line 1742 "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 1746 "parser.yy"
     7404#line 1747 "parser.yy"
    74057405    { (yyval.in) = 0; }
    74067406    break;
     
    74097409
    74107410/* Line 1806 of yacc.c  */
    7411 #line 1748 "parser.yy"
     7411#line 1749 "parser.yy"
    74127412    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    74137413    break;
     
    74167416
    74177417/* Line 1806 of yacc.c  */
    7418 #line 1750 "parser.yy"
     7418#line 1751 "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"
     7425#line 1755 "parser.yy"
    74267426    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    74277427    break;
     
    74307430
    74317431/* Line 1806 of yacc.c  */
    7432 #line 1755 "parser.yy"
     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 1760 "parser.yy"
     7439#line 1761 "parser.yy"
    74407440    { (yyval.in) = 0; }
    74417441    break;
     
    74447444
    74457445/* Line 1806 of yacc.c  */
    7446 #line 1762 "parser.yy"
     7446#line 1763 "parser.yy"
    74477447    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    74487448    break;
     
    74517451
    74527452/* Line 1806 of yacc.c  */
    7453 #line 1763 "parser.yy"
     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 1765 "parser.yy"
     7460#line 1766 "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 1781 "parser.yy"
     7467#line 1782 "parser.yy"
    74687468    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    74697469    break;
     
    74727472
    74737473/* Line 1806 of yacc.c  */
    7474 #line 1787 "parser.yy"
     7474#line 1788 "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 1793 "parser.yy"
     7481#line 1794 "parser.yy"
    74827482    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    74837483    break;
     
    74867486
    74877487/* Line 1806 of yacc.c  */
    7488 #line 1796 "parser.yy"
     7488#line 1797 "parser.yy"
    74897489    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74907490    break;
     
    74937493
    74947494/* Line 1806 of yacc.c  */
    7495 #line 1798 "parser.yy"
     7495#line 1799 "parser.yy"
    74967496    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74977497    break;
     
    75007500
    75017501/* Line 1806 of yacc.c  */
    7502 #line 1800 "parser.yy"
     7502#line 1801 "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 1802 "parser.yy"
     7509#line 1803 "parser.yy"
    75107510    { (yyval.en) = (yyvsp[(4) - (6)].en); }
    75117511    break;
     
    75147514
    75157515/* Line 1806 of yacc.c  */
    7516 #line 1826 "parser.yy"
     7516#line 1827 "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 1828 "parser.yy"
     7523#line 1829 "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 1830 "parser.yy"
     7530#line 1831 "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 1836 "parser.yy"
     7537#line 1837 "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 1838 "parser.yy"
     7544#line 1839 "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 1843 "parser.yy"
     7551#line 1844 "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 1849 "parser.yy"
     7558#line 1850 "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 1854 "parser.yy"
     7565#line 1855 "parser.yy"
    75667566    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75677567    break;
     
    75707570
    75717571/* Line 1806 of yacc.c  */
    7572 #line 1856 "parser.yy"
     7572#line 1857 "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 1862 "parser.yy"
     7579#line 1863 "parser.yy"
    75807580    { (yyval.tclass) = DeclarationNode::Otype; }
    75817581    break;
     
    75847584
    75857585/* Line 1806 of yacc.c  */
    7586 #line 1864 "parser.yy"
     7586#line 1865 "parser.yy"
    75877587    { (yyval.tclass) = DeclarationNode::Ftype; }
    75887588    break;
     
    75917591
    75927592/* Line 1806 of yacc.c  */
    7593 #line 1866 "parser.yy"
     7593#line 1867 "parser.yy"
    75947594    { (yyval.tclass) = DeclarationNode::Dtype; }
    75957595    break;
     
    75987598
    75997599/* Line 1806 of yacc.c  */
    7600 #line 1871 "parser.yy"
     7600#line 1872 "parser.yy"
    76017601    { (yyval.decl) = 0; }
    76027602    break;
     
    76057605
    76067606/* Line 1806 of yacc.c  */
    7607 #line 1873 "parser.yy"
     7607#line 1874 "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 1878 "parser.yy"
     7614#line 1879 "parser.yy"
    76157615    {
    76167616                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    76227622
    76237623/* Line 1806 of yacc.c  */
    7624 #line 1883 "parser.yy"
     7624#line 1884 "parser.yy"
    76257625    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    76267626    break;
     
    76297629
    76307630/* Line 1806 of yacc.c  */
    7631 #line 1885 "parser.yy"
     7631#line 1886 "parser.yy"
    76327632    { (yyval.decl) = 0; }
    76337633    break;