Index: doc/LaTeXmacros/common.tex =================================================================== --- doc/LaTeXmacros/common.tex (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ doc/LaTeXmacros/common.tex (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -1,11 +1,11 @@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%% -%% +%% %% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo %% %% The contents of this file are covered under the licence agreement in the %% file "LICENCE" distributed with Cforall. -%% -%% common.tex -- -%% +%% +%% common.tex -- +%% %% Author : Peter A. Buhr %% Created On : Sat Apr 9 10:06:17 2016 @@ -41,4 +41,6 @@ \newcommand{\CCeleven}{\rm C\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name \newcommand{\Celeven}{C11\xspace} % C11 symbolic name +\newcommand{\Csharp}{\rm C\hbox{\#}\xspace} % C# symbolic name + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -124,7 +126,7 @@ \newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi} -% inline text and code index (cannot use ©) +% inline text and code index (cannot use �) \newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}} -% code index (cannot use ©) +% code index (cannot use �) \newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}} @@ -226,25 +228,29 @@ % CFA programming language, based on ANSI C (with some gcc additions) -\lstdefinelanguage{CFA}[ANSI]{C}{ - morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto, - _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__, - fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert, - _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,}, +\lstdefinelanguage{Pseudo}{ + morekeywords={string,uint,int,bool,float},% + sensitive=true,% + morecomment=[l]{//},% + morecomment=[s]{/*}{*/},% + morestring=[b]',% + morestring=[b]",% + morestring=[s]{`}{`},% }% \lstset{ -language=CFA, +language=Pseudo, columns=fullflexible, -basicstyle=\linespread{0.9}\sf, % reduce line spacing and use sanserif font -stringstyle=\tt, % use typewriter font -tabsize=4, % 4 space tabbing +basicstyle=\linespread{0.9}\tt\small, % reduce line spacing and use typewriter font +stringstyle=\sf\color{Mahogany}, % use sanserif font +commentstyle=\itshape\color{OliveGreen}, % green and italic comments +tabsize=4, % 4 space tabbing xleftmargin=\parindentlnth, % indent code to paragraph indentation -extendedchars=true, % allow ASCII characters in the range 128-255 -escapechar=§, % escape to latex in CFA code +extendedchars=true, % allow ASCII characters in the range 128-255 +escapechar=§, % escape to latex in CFA code mathescape=true, % allow $...$ LaTeX math escapes in code -%keepspaces=true, % +%keepspaces=true, % showstringspaces=false, % do not show spaces with cup -showlines=true, % show blank lines at end of code -aboveskip=4pt, % spacing above/below code block +showlines=true, % show blank lines at end of code +aboveskip=4pt, % spacing above/below code block belowskip=3pt, moredelim=**[is][\color{red}]{®}{®}, % red highlighting @@ -253,10 +259,47 @@ moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords % replace/adjust listing characters that look bad in sanserif -literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 +literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 {©}{{\"u}}1 {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1 {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2, }% +% CFA programming language, based on ANSI C (with some gcc additions) +\lstdefinelanguage{CFA}[ANSI]{C}{ + morekeywords=[1]{_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto, + _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__, + fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert, + _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,}, + morekeywords=[2]{mutex,nomutex,thread,wait,signal,accept,monitor} +}% + +\lstset{ +language=CFA, +columns=fullflexible, +basicstyle=\linespread{0.9}\tt\small, % reduce line spacing and use typewriter font +keywordstyle=[2]\color{blue}, % second set of keywords for concurency +stringstyle=\sf\color{Mahogany}, % use sanserif font +commentstyle=\itshape\color{OliveGreen}, % green and italic comments +tabsize=4, % 4 space tabbing +xleftmargin=\parindentlnth, % indent code to paragraph indentation +extendedchars=true, % allow ASCII characters in the range 128-255 +escapechar=§, % escape to latex in CFA code +mathescape=true, % allow $...$ LaTeX math escapes in code +%keepspaces=true, % +showstringspaces=false, % do not show spaces with cup +showlines=true, % show blank lines at end of code +aboveskip=4pt, % spacing above/below code block +belowskip=3pt, +moredelim=**[is][\color{red}]{®}{®}, % red highlighting +moredelim=**[is][\color{blue}]{ß}{ß}, % blue highlighting +moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting +moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords +% replace/adjust listing characters that look bad in sanserif +literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 {©}{{\"u}}1 + {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1 + {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2, +}% + \lstMakeShortInline© % single-character for \lstinline + \let\Oldthebibliography\thebibliography Index: doc/proposals/concurrency/.gitignore =================================================================== --- doc/proposals/concurrency/.gitignore (revision a1e67ddc023331e04cc5481931be1d0923efc441) +++ doc/proposals/concurrency/.gitignore (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -0,0 +1,21 @@ +concurrency.aux +concurrency.acn +concurrency.acr +concurrency.alg +concurrency.bbl +concurrency.blg +concurrency.brf +concurrency.dvi +concurrency.glg +concurrency.glo +concurrency.gls +concurrency.idx +concurrency.ind +concurrency.ist +concurrency.log +concurrency.out +concurrency.pdf +concurrency.ps +version.aux +monitor.tex +ext_monitor.tex Index: doc/proposals/concurrency/Makefile =================================================================== --- doc/proposals/concurrency/Makefile (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ doc/proposals/concurrency/Makefile (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -12,4 +12,6 @@ FIGURES = ${addsuffix .tex, \ + monitor \ + ext_monitor \ } @@ -32,5 +34,5 @@ clean : - rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist \ + rm -f *.bbl *.aux *.dvi *.idx *.ilg *.ind *.brf *.out *.log *.toc *.blg *.pstex_t *.cf *.glg *.glo *.gls *.ist *.acn *.acr *.alg \ ${FIGURES} ${PICTURES} ${PROGRAMS} ${GRAPHS} ${basename ${DOCUMENT}}.ps ${DOCUMENT} @@ -58,4 +60,5 @@ # Run again to get index title into table of contents ${LaTeX} ${basename $@}.tex + -./bump_ver.sh ${LaTeX} ${basename $@}.tex @@ -76,4 +79,5 @@ fig2dev -L pstex_t -p $@ $< > $@_t + # Local Variables: # # compile-command: "make" # Index: doc/proposals/concurrency/bump_ver.sh =================================================================== --- doc/proposals/concurrency/bump_ver.sh (revision a1e67ddc023331e04cc5481931be1d0923efc441) +++ doc/proposals/concurrency/bump_ver.sh (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -0,0 +1,6 @@ +#!/bin/bash +if [ ! -f version ]; then + echo "0.0.0" > version +fi + +sed -r 's/([0-9]+\.[0-9]+.)([0-9]+)/echo "\1\$((\2+1))" > version/ge' version > /dev/null Index: doc/proposals/concurrency/concurrency.tex =================================================================== --- doc/proposals/concurrency/concurrency.tex (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ doc/proposals/concurrency/concurrency.tex (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -1,10 +1,10 @@ % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended -% inline code �...� (copyright symbol) emacs: C-q M-) -% red highlighting �...� (registered trademark symbol) emacs: C-q M-. -% blue highlighting �...� (sharp s symbol) emacs: C-q M-_ -% green highlighting �...� (cent symbol) emacs: C-q M-" -% LaTex escape �...� (section symbol) emacs: C-q M-' -% keyword escape �...� (pilcrow symbol) emacs: C-q M-^ +% inline code ©...© (copyright symbol) emacs: C-q M-) +% red highlighting ®...® (registered trademark symbol) emacs: C-q M-. +% blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ +% green highlighting ¢...¢ (cent symbol) emacs: C-q M-" +% LaTex escape §...§ (section symbol) emacs: C-q M-' +% keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^ % math escape $...$ (dollar symbol) @@ -24,5 +24,5 @@ \usepackage{graphicx} \usepackage{tabularx} -\usepackage{glossaries} +\usepackage[acronym]{glossaries} \usepackage{varioref} % extended references \usepackage{inconsolata} @@ -33,8 +33,12 @@ \usepackage[usenames]{color} \usepackage[pagewise]{lineno} +\usepackage{fancyhdr} \renewcommand{\linenumberfont}{\scriptsize\sffamily} \input{common} % bespoke macros used in the document \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref} \usepackage{breakurl} + +\usepackage{tikz} +\def\checkmark{\tikz\fill[scale=0.4](0,.35) -- (.25,0) -- (1,.7) -- (.25,.15) -- cycle;} \renewcommand{\UrlFont}{\small\sf} @@ -58,4 +62,5 @@ \newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace} \newcommand{\code}[1]{\lstinline{#1}} +\newcommand{\pseudo}[1]{\lstinline[language=Pseudo]{#1}} \input{glossary} @@ -67,5 +72,10 @@ \setcounter{secnumdepth}{3} % number subsubsections \setcounter{tocdepth}{3} % subsubsections in table of contents +% \linenumbers % comment out to turn off line numbering \makeindex +\pagestyle{fancy} +\fancyhf{} +\cfoot{\thepage} +\rfoot{v\input{version}} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -81,16 +91,17 @@ \maketitle \section{Introduction} -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. -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. - -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. +This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible core is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level construct as the basis of the concurrency in \CFA. +Indeed, for highly productive parallel programming high-level approaches are much more popular\cite{HPP:Study}. Examples are task based parallelism, message passing, implicit threading. + +There are actually two problems that need to be solved in the design of the concurrency for a language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization while parallelism tools are more about performance, cost and resource utilization. \section{Concurrency} -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. +Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared state, some languages and libraries simply disallow mutable shared-state (Erlang\cite{Erlang}, Haskell\cite{Haskell}, Akka (Scala)\cite{Akka}). In these paradigms, interaction among concurrent objects rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This project proposes Monitors\cite{Hoare74} as the core concurrency construct. +\\ Finally, 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. -\section{Monitors} -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 : +\subsection{Monitors} +A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java\cite{Java} or \uC\cite{uC++book} but does not strictly require OOP semantics. The only requirements is the ability to declare a handle to a shared object and a set of routines that act on it : \begin{lstlisting} typedef /*some monitor type*/ monitor; @@ -103,45 +114,39 @@ \end{lstlisting} -\subsection{Call semantics} \label{call} -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. - -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 : +\subsubsection{Call semantics} \label{call} +The above example of monitors already displays some of their intrinsic caracteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable. +\\ + +Another aspect to consider is when a monitor acquires its mutual exclusion. Indeed, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual exclusion on entry. Examples of this can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following example : \begin{lstlisting} mutex struct counter_t { /*...*/ }; - void ?{}(counter_t & mutex this); + void ?{}(counter_t & nomutex this); int ++?(counter_t & mutex this); - void ?{}(int * this, counter_t & mutex cnt); - - bool is_zero(counter_t & nomutex this) { - int val = this; - return val == 0; - } -\end{lstlisting} -*semantics of the declaration of \code{mutex struct counter_t} will be discussed in details in \ref{data} - -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} ). + void ?{}(Int * this, counter_t & mutex cnt); +\end{lstlisting} +*semantics of the declaration of \code{mutex struct counter_t} are discussed in details in section \ref{data} +\\ + +This example is of a monitor implementing an atomic counter. Here, the constructor uses the \code{nomutex} keyword to signify that it does not acquire the coroutine mutual exclusion when constructing. This is because object not yet constructed should never be shared and therefore do not require mutual exclusion. The prefix increment operator +uses \code{mutex} to protect the incrementing process from race conditions. Finally, we have a conversion operator from \code{counter_t} to \code{Int}. This conversion may or may not require the \code{mutex} key word depending whether or not reading an \code{Int} is an atomic operation or not. +\\ Having 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. +\\ Regardless of which keyword is kept, it is important to establish when mutex/nomutex may be used depending on type parameters. \begin{lstlisting} - int f01(monitor & mutex m); - int f02(const monitor & mutex m); - int f03(monitor * mutex m); - int f04(monitor * mutex * m); - int f05(monitor ** mutex m); - int f06(monitor[10] mutex m); - int f07(monitor[] mutex m); - int f08(vector(monitor) & mutex m); - int f09(list(monitor) & mutex m); - int f10([monitor*, int] & mutex m); - int f11(graph(monitor*) & mutex m); -\end{lstlisting} - -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. - -\subsection{Data semantics} \label{data} + int f1(monitor & mutex m); + int f2(const monitor & mutex m); + int f3(monitor ** mutex m); + int f4(monitor *[] mutex m); + int f5(graph(monitor*) & mutex m); +\end{lstlisting} + +The problem is to indentify which object(s) should be acquired. Furthermore we also need to acquire each objects only once. In case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entering. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object will be acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths aren't necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5} which uses a custom graph of monitors. To keep everyone as sane as possible\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter (ignoring potential qualifiers and indirections). + +\subsubsection{Data semantics} \label{data} Once 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}: \begin{lstlisting} @@ -150,5 +155,5 @@ }; - void ?{}(counter_t & mutex this) { + void ?{}(counter_t & nomutex this) { this.cnt = 0; } @@ -165,12 +170,11 @@ Thread 1 & Thread 2 \\ \begin{lstlisting} - void main(counter_t & mutex c) { + void f(counter_t & mutex c) { for(;;) { - int count = c; - sout | count | endl; + sout | (int)c | endl; } } \end{lstlisting} &\begin{lstlisting} - void main(counter_t & mutex c) { + void g(counter_t & mutex c) { for(;;) { ++c; @@ -194,5 +198,5 @@ \end{lstlisting} -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 : +This code acquires both locks before entering the critical section. In practice, writing multi-locking routines that can not lead to deadlocks can be very tricky. Having language level support for such feature is therefore a significant asset for \CFA. However, this does have significant repercussions relating to scheduling (see \ref{insched} and \ref{extsched}). Furthermore, the ability to acquire multiple monitors at the same time does incur a significant pitfall even without looking into scheduling. For example : \begin{lstlisting} void foo(A & mutex a, B & mutex a) { @@ -213,9 +217,12 @@ \end{lstlisting} -TODO: dig further into monitor order aquiring - -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. - -\subsubsection{Internal scheduling} \label{insched} +Recursive mutex routine calls are allowed in \CFA but if not done carefully it can lead to nested monitor call problems\cite{Lister77}. These problems which are a specific implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{bar} but explicit ordering in the case of \code{baz}. This subtle mistake can mean that calling these two functions concurrently will lead to deadlocks, depending on the implicit ordering matching the explicit ordering. As shown on several occasion\cit, there isn't really any solutions to this problem, users simply need to be carefull when acquiring multiple monitors at the same time. + +\subsubsection{Implementation Details: Interaction with polymorphism} +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. + +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. + +\subsection{Internal scheduling} \label{insched} Monitors 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 : @@ -236,5 +243,5 @@ \end{lstlisting} -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. +Here routine \code{foo} waits on the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This semantic can easily be extended to multi-monitor calls by offering the same guarantee. \begin{center} @@ -263,5 +270,5 @@ \end{center} -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 : +A direct extension of the single monitor semantics would be to release all locks when waiting and transferring ownership of all locks when signalling. However, for the purpose of synchronization it may be usefull to only release some of the locks but keep others. On the technical side, partially releasing lock is feasible but from the user perspective a choice must be made for the syntax of this feature. It is possible to do without any extra syntax by relying on order of acquisition (Note that here the use of helper routines is irrelevant, only routines the acquire mutual exclusion have an impact on internal scheduling): \begin{center} @@ -270,7 +277,9 @@ \hline \begin{lstlisting} +condition e; + void foo(monitor & mutex a, monitor & mutex b) { - wait(a.e); + wait(e); } @@ -282,4 +291,6 @@ foo(a,b); \end{lstlisting} &\begin{lstlisting} +condition e; + void bar(monitor & mutex a, monitor & nomutex b) { @@ -289,9 +300,11 @@ void foo(monitor & mutex a, monitor & mutex b) { - wait(a.e); + wait(e); } bar(a, b); \end{lstlisting} &\begin{lstlisting} +condition e; + void bar(monitor & mutex a, monitor & nomutex b) { @@ -301,5 +314,5 @@ void baz(monitor & nomutex a, monitor & mutex b) { - wait(a.e); + wait(e); } @@ -310,9 +323,11 @@ This can be interpreted in two different ways : +\begin{flushleft} \begin{enumerate} - \item \code{wait} atomically releases the monitors \underline{theoretically} acquired by the inner-most mutex routine. - \item \code{wait} atomically releases the monitors \underline{actually} acquired by the inner-most mutex routine. + \item \code{wait} atomically releases the monitors acquired by the inner-most routine, \underline{ignoring} nested calls. + \item \code{wait} atomically releases the monitors acquired by the inner-most routine, \underline{considering} nested calls. \end{enumerate} -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. +\end{flushleft} +While the difference between these two is subtle, it has a significant impact. In the first case it means that the calls to \code{foo} would behave the same in Context 1 and 2. This semantic would also mean that the call to \code{wait} in routine \code{baz} would only release \code{monitor b}. While this may seem intuitive with these examples, it does have one significant implication, it creates a strong distinction between acquiring multiple monitors in sequence and acquiring the same monitors simulatenously, i.e. : \begin{center} @@ -334,5 +349,5 @@ \end{center} -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. +This is not intuitive because even if both methods display the same monitors state both inside and outside the critical section respectively, the behavior is different. Furthermore, the actual acquiring order will be exaclty the same since acquiring a monitor from inside its mutual exclusion is a no-op. This means that even if the data and the actual control flow are the same using both methods, the behavior of the \code{wait} will be different. The alternative is option 2, that is releasing acquired monitors, \underline{considering} nesting. This solves the issue of having the two acquiring method differ at the cost of making routine \code{foo} behave differently depending on from which context it is called (Context 1 or 2). Indeed in Context 2, routine \code{foo} actually behaves like routine \code{baz} rather than having the same behavior than in Context 1. The fact that both implicit approaches can be unintuitive depending on the perspective may be a sign that the explicit approach is superior. For this reason this \CFA does not support implicit monitor releasing and uses explicit semantics. \\ @@ -411,5 +426,5 @@ \\ -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 : +All these cases have their pros and cons. Case 1 is more distinct because it means programmers need to be carefull about where the condition is initialized as well as where it is used. On the other hand, it is very clear and explicitly states which monitor is released and which monitor stays acquired. This is similar to Case 2, which releases only the monitors explictly listed. However, in Case 2, calling the \code{wait} routine instead of the \code{waitRelease} routine releases all the acquired monitor. The Case 3 is an improvement on that since it releases all the monitors except those specified. The result is that the \code{wait} routine can be written as follows : \begin{lstlisting} void wait(condition & cond) { @@ -419,5 +434,7 @@ This 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 : \begin{lstlisting} -extern void doStuff(); +monitor global; + +extern void doStuff(); //uses global void foo(monitor & mutex m) { @@ -426,7 +443,9 @@ //... } -\end{lstlisting} - -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 : + +foo(global); +\end{lstlisting} + +Indeed, if Case 2 or 3 are chosen it any code can violate the mutual exclusion of the calling code by issuing calls to \code{wait} or \code{waitHold} in a nested monitor context. Case 2 can be salvaged by removing the \code{wait} routine from the API but Case 3 cannot prevent users from calling \code{waitHold(someCondition, [])}. For this reason the syntax proposed in Case 3 is rejected. Note that the syntax proposed in case 1 and 2 are not exclusive. Indeed, by supporting two types of condition both cases can be supported : \begin{lstlisting} struct condition { /*...*/ }; @@ -443,10 +462,11 @@ \end{lstlisting} -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. +Regardless of the option chosen for wait semantics, signal must be symmetrical. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) that call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor. Finally, 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. +\\ \subsection{External scheduling} \label{extsched} -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. +As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demonstrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages. \begin{center} @@ -458,7 +478,6 @@ condition c; public: - void f(); - void g() { signal} - void h() { wait(c); } + void f() { signal(c)} + void g() { wait(c); } private: } @@ -468,6 +487,5 @@ public: void f(); - void g(); - void h() { _Accept(g); } + void g() { _Accept(f); } private: } @@ -477,7 +495,8 @@ In 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. +\\ \subsubsection{Loose object definitions} -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 : +In \uC, monitor declarations include an exhaustive list of monitor operations. Since \CFA is not object oriented it becomes both more difficult to implement but also less clear for the user : \begin{lstlisting} @@ -485,27 +504,54 @@ void f(A & mutex a); - void g(A & mutex a); - void h(A & mutex a) { accept(g); } -\end{lstlisting} - -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 : -\begin{lstlisting} - accept( void g(mutex struct A & mutex a) ) - mutex struct A {}; - - void f(A & mutex a) { accept(g); } - void g(A & mutex a); -\end{lstlisting} - -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 : \\ -\begin{tabular}[t]{l l} + void g(A & mutex a) { accept(f); } +\end{lstlisting} + +However, external scheduling is an example where implementation constraints become visible from the interface. Indeed, ince there is no hard limit to the number of threads trying to acquire a monitor concurrently, performance is a significant concern. Here is the pseudo code for the entering phase of a monitor : + +\begin{center} +\begin{tabular}{l} +\begin{lstlisting}[language=Pseudo] + if monitor is free : + enter + elif monitor accepts me : + enter + else : + block +\end{lstlisting} +\end{tabular} +\end{center} + +For the \pseudo{monitor is free} condition it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pseudo{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure : + +\begin{center} +{\resizebox{0.4\textwidth}{!}{\input{monitor}}} +\end{center} + +There are other alternatives to these pictures but in the case of this picture implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number of acceptor. However, this relies on the fact that all the acceptable routines are declared with the monitor type. For OO languages this doesn't compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this isn't the case, routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units. +The alternative would be to have a picture more like this one: + +\begin{center} +{\resizebox{0.4\textwidth}{!}{\input{ext_monitor}}} +\end{center} + +Not storing the queues inside the monitor means that the storage can vary between routines, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to accept to check if a routine is already queued in. + +At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed. + +In either cases here are a few alternatives for the different syntaxes this syntax : \\ +\begin{center} +{\renewcommand{\arraystretch}{1.5} +\begin{tabular}[t]{l @{\hskip 0.35in} l} +\hline +\multicolumn{2}{ c }{\code{accept} on type}\\ +\hline Alternative 1 & Alternative 2 \\ \begin{lstlisting} mutex struct A -accept( void g(A & mutex a) ) +accept( void f(A & mutex a) ) {}; \end{lstlisting} &\begin{lstlisting} mutex struct A {} -accept( void g(A & mutex a) ); +accept( void f(A & mutex a) ); \end{lstlisting} \\ @@ -513,5 +559,5 @@ \begin{lstlisting} mutex struct A { - accept( void g(A & mutex a) ) + accept( void f(A & mutex a) ) }; @@ -519,9 +565,23 @@ mutex struct A { accept : - void g(A & mutex a) ); + void f(A & mutex a) ); }; -\end{lstlisting} +\end{lstlisting}\\ +\hline +\multicolumn{2}{ c }{\code{accept} on routine}\\ +\hline +\begin{lstlisting} +mutex struct A {}; + +void f(A & mutex a) + +accept( void f(A & mutex a) ) +void g(A & mutex a) { + /*...*/ +} +\end{lstlisting}&\\ \end{tabular} - +} +\end{center} An other aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine should be scheduled regardless of the overload used. However, this could easily be extended in the future. @@ -554,5 +614,5 @@ \end{lstlisting} -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. +This is unambiguous. Both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{a} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{b}). This behavior can be extended to multi-monitor accept statment as follows. \begin{lstlisting} @@ -569,18 +629,13 @@ Note that the set of monitors passed to the \code{accept} statement must be entirely contained in the set of monitor already acquired in the routine. \code{accept} used in any other context is Undefined Behaviour. -\subsection{Implementation Details} -\textbf{\large{Work in progress...}} -\subsubsection{Interaction with polymorphism} -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. - -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. - -\subsubsection{External scheduling queues} -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. +\subsubsection{Implementation Details: External scheduling queues} +To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonnable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program. \subsection{Other concurrency tools} - +TO BE CONTINUED... + +\newpage \section{Parallelism} -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. +Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being an ever growing challenge, parallelism has become the new source of greatest performance \cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach of parallelism is to use \glspl{kthread}. However since these have significant costs and limitations \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues which all have strengths and weaknesses. \subsection{User-level threads} @@ -590,102 +645,203 @@ \subsection{Jobs and thread pools} -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}. +The approach on the opposite end of the spectrum is to base parallelism on \glspl{job}. Indeed, \glspl{job} offer limited flexibility but at the benefit of a simpler user interface. In \gls{job} based systems users express parallelism as units of work and the dependency graph (either explicit or implicit) that tie them together. This means users need not to worry about concurrency but significantly limits the interaction that can occur between different jobs. Indeed, any \gls{job} that blocks also blocks the underlying \gls{kthread}, this effectively mean the CPU utilization, and therefore throughput, will suffer noticeably. +The golden standard of this implementation is Intel's TBB library\cite{TBB}. \subsection{Fibers : user-level threads without preemption} Finally, in the middle of the flexibility versus complexity spectrum lay \glspl{fiber} which offer \glspl{uthread} without the complexity of preemption. This means users don't have to worry about other \glspl{fiber} suddenly executing between two instructions which signficantly reduces complexity. However, any call to IO or other concurrency primitives can lead to context switches. Furthermore, users can also block \glspl{fiber} in the middle of their execution without blocking a full processor core. This means users still have to worry about mutual exclusion, deadlocks and race conditions in their code, raising the complexity significantly. -\cite{Go} +An example of a language that uses fibers is Go\cite{Go} \subsection{Paradigm performance} -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. -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. - -\section{Parallelism in \CFA} -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. - -\subsection{Kernel core}\label{kernel} -At the ro -\subsubsection{Threads} -\CFA threads have all the caracteristiques of - -\subsection{High-level options}\label{tasks} - -\subsubsection{Thread interface} -constructors destructors - initializer lists -monitors - -\subsubsection{Futures} - -\subsubsection{Implicit threading} -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. - -\begin{center} -\begin{tabular}[t]{|c|c|c|} -Sequential & System Parallel & Language Parallel \\ -\begin{lstlisting} -void big_sum(int* a, int* b, - int* out, - size_t length) -{ - for(int i = 0; i < length; ++i ) { - out[i] = a[i] + b[i]; - } -} - - - - - -int* a[10000]; -int* b[10000]; -int* c[10000]; -//... fill in a and b ... -big_sum(a, b, c, 10000); -\end{lstlisting} &\begin{lstlisting} -void big_sum(int* a, int* b, - int* out, - size_t length) -{ - range ar(a, a + length); - range br(b, b + length); - range or(out, out + length); - parfor( ai, bi, oi, - [](int* ai, int* bi, int* oi) { - oi = ai + bi; - }); -} - -int* a[10000]; -int* b[10000]; -int* c[10000]; -//... fill in a and b ... -big_sum(a, b, c, 10000); -\end{lstlisting}&\begin{lstlisting} -void big_sum(int* a, int* b, - int* out, - size_t length) -{ - for (ai, bi, oi) in (a, b, out) { - oi = ai + bi; - } -} - - - - - -int* a[10000]; -int* b[10000]; -int* c[10000]; -//... fill in a and b ... -big_sum(a, b, c, 10000); -\end{lstlisting} +While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pin the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms will show better performance but it all strongly depends on the usage. Having mostly indepent units of work to execute almost guarantess that the \gls{job} based system will have the best performance. However, add interactions between jobs and the processor utilisation might suffer. User-level threads may allow maximum ressource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum. Furthermore, if the units of uninterrupted work are large enough the paradigm choice will be largely amorticised by the actual work done. + +\section{\CFA 's Thread Building Blocks} +As a system level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. With this said, it is possible to deconstruct the three paradigms details aboved in order to get simple building blocks. Here is a table showing the core caracteristics of the mentionned paradigms : +\begin{center} +\begin{tabular}[t]{| r | c | c |} +\cline{2-3} +\multicolumn{1}{ c| }{} & Has a stack & Preemptive \\ +\hline +\Glspl{job} & X & X \\ +\hline +\Glspl{fiber} & \checkmark & X \\ +\hline +\Glspl{uthread} & \checkmark & \checkmark \\ +\hline \end{tabular} \end{center} -\subsection{Machine setup}\label{machine} -Threads are all good and well but wee still some OS support to fully utilize available hardware. - -\textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads? +As shown in section \ref{cfaparadigms} these different blocks being available in \CFA it is trivial to reproduce any of these paradigm. + +\subsection{Thread Interface} +The basic building blocks of \CFA are \glspl{cfathread}. By default these are implemented as \glspl{uthread} and as such offer a flexible and lightweight threading interface (lightweight comparatievely to \glspl{kthread}). A thread can be declared using a struct declaration prefix with the \code{thread} as follows : + +\begin{lstlisting} + thread struct foo {}; +\end{lstlisting} + +Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use some function pointer representation as the interface of threads (for example : \Csharp \cite{Csharp} and Scala \cite{Scala}). However, we consider that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is definetely a special routine in \CFA, we can reuse the existing syntax for declaring routines with unordinary name, i.e. operator overloading. As such the \code{main} routine of a thread can be defined as such : +\begin{lstlisting} + thread struct foo {}; + + void ?main(thread foo* this) { + /*... Some useful code ...*/ + } +\end{lstlisting} + +With these semantics it is trivial to write a thread type that takes a function pointer as parameter and executes it on its stack asynchronously : +\begin{lstlisting} + typedef void (*voidFunc)(void); + + thread struct FuncRunner { + voidFunc func; + }; + + //ctor + void ?{}(thread FuncRunner* this, voidFunc inFunc) { + func = inFunc; + } + + //main + void ?main(thread FuncRunner* this) { + this->func(); + } +\end{lstlisting} + +% In this example \code{func} is a function pointer stored in \acrfull{tls}, which is \CFA is both easy to use and completly typesafe. + +Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is not needed. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} once the constructor has completed and \code{join} before the destructor runs. +\begin{lstlisting} +thread struct FuncRunner; //FuncRunner declared above + +void world() { + sout | "World!" | endl; +} + +void main() { + FuncRunner run = {world}; + //Thread run forks here + + //Print to "Hello " and "World!" will be run concurrently + sout | "Hello " | endl; + + //Implicit join at end of scope +} +\end{lstlisting} +This semantic has several advantages over explicit semantics : typesafety is guaranteed, any thread will always be started and stopped exaclty once and users can't make any progamming errors. Furthermore it naturally follows the memory allocation semantics which means users don't need to learn multiple semantics. + +These semantics also naturally scale to multiple threads meaning basic synchronisation is very simple : +\begin{lstlisting} + thread struct MyThread { + //... + }; + + //ctor + void ?{}(thread MyThread* this) {} + + //main + void ?main(thread MyThread* this) { + //... + } + + void foo() { + MyThread thrds[10]; + //Start 10 threads at the beginning of the scope + + DoStuff(); + + //Wait for the 10 threads to finish + } +\end{lstlisting} + +\newpage +\large{\textbf{WORK IN PROGRESS}} +\subsection{The \CFA Kernel : Processors, Clusters and Threads}\label{kernel} + + +\subsection{Paradigms}\label{cfaparadigms} +Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. + +% \subsection{High-level options}\label{tasks} +% +% \subsubsection{Thread interface} +% constructors destructors +% initializer lists +% monitors +% +% \subsubsection{Futures} +% +% \subsubsection{Implicit threading} +% 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. +% +% \begin{center} +% \begin{tabular}[t]{|c|c|c|} +% Sequential & System Parallel & Language Parallel \\ +% \begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% for(int i = 0; i < length; ++i ) { +% out[i] = a[i] + b[i]; +% } +% } +% +% +% +% +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting} &\begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% range ar(a, a + length); +% range br(b, b + length); +% range or(out, out + length); +% parfor( ai, bi, oi, +% [](int* ai, int* bi, int* oi) { +% oi = ai + bi; +% }); +% } +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting}&\begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% for (ai, bi, oi) in (a, b, out) { +% oi = ai + bi; +% } +% } +% +% +% +% +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting} +% \end{tabular} +% \end{center} +% +% \subsection{Machine setup}\label{machine} +% Threads are all good and well but wee still some OS support to fully utilize available hardware. +% +% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads? + +\section{Putting it all together} \section{Future work} @@ -696,4 +852,5 @@ \clearpage +\printglossary[type=\acronymtype] \printglossary Index: doc/proposals/concurrency/ext_monitor.fig =================================================================== --- doc/proposals/concurrency/ext_monitor.fig (revision a1e67ddc023331e04cc5481931be1d0923efc441) +++ doc/proposals/concurrency/ext_monitor.fig (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -0,0 +1,94 @@ +#FIG 3.2 Produced by xfig version 3.2.5c +Landscape +Center +Inches +Letter +100.00 +Single +-2 +1200 2 +5 1 0 1 -1 -1 0 0 -1 0.000 0 1 0 0 3150.000 3450.000 3150 3150 2850 3450 3150 3750 +5 1 0 1 -1 -1 0 0 -1 0.000 0 1 0 0 3150.000 4350.000 3150 4050 2850 4350 3150 4650 +6 5850 1950 6150 2250 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 2100 105 105 6000 2100 6105 2205 +4 1 -1 0 0 0 10 0.0000 2 105 90 6000 2160 d\001 +-6 +6 5850 1650 6150 1950 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 1800 105 105 6000 1800 6105 1905 +4 1 -1 0 0 0 10 0.0000 2 105 90 6000 1860 b\001 +-6 +6 5100 1800 5400 2100 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 1950 105 105 5250 1950 5355 1950 +4 1 -1 0 0 0 10 0.0000 2 105 120 5250 2010 Y\001 +-6 +6 5100 2100 5400 2400 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 2250 105 105 5250 2250 5355 2250 +4 1 -1 0 0 0 10 0.0000 2 105 120 5250 2295 X\001 +-6 +6 3000 5400 7200 5700 +1 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 3150 5550 80 80 3150 5550 3230 5630 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4500 5550 105 105 4500 5550 4605 5655 +1 3 0 1 -1 -1 0 0 4 0.000 1 0.0000 6000 5550 105 105 6000 5550 6105 5655 +4 0 -1 0 0 0 12 0.0000 2 135 1035 4725 5625 blocked task\001 +4 0 -1 0 0 0 12 0.0000 2 135 870 3300 5625 active task\001 +4 0 -1 0 0 0 12 0.0000 2 180 930 6225 5625 routine ptrs\001 +-6 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3300 3600 105 105 3300 3600 3405 3705 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3600 3600 105 105 3600 3600 3705 3705 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6600 3900 105 105 6600 3900 6705 4005 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6900 3900 105 105 6900 3900 7005 4005 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 2700 105 105 6000 2700 6105 2805 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 2400 105 105 6000 2400 6105 2505 +1 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 5100 4575 80 80 5100 4575 5180 4655 +2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 + 4050 2925 5475 2925 5475 3225 4050 3225 4050 2925 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 5850 2850 6075 3000 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3150 3750 3750 3750 3750 4050 3150 4050 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 3150 3450 3750 3450 3900 3675 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 3750 3150 3600 3375 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 3150 4350 3750 4350 3900 4575 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 3750 4050 3600 4275 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3150 4650 3750 4650 3750 4950 4950 4950 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 6450 3750 6300 3975 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 4950 4950 5175 5100 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 9 + 5250 4950 6450 4950 6450 4050 7050 4050 7050 3750 6450 3750 + 6450 2850 6150 2850 6150 1650 +2 2 1 1 -1 -1 0 0 -1 4.000 0 0 0 0 0 5 + 5850 4200 5850 3300 4350 3300 4350 4200 5850 4200 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 5250 2850 5850 2850 5850 1650 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3150 3150 3750 3150 3750 2850 5325 2850 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2 + 1 1 1.00 60.00 120.00 + 7 1 1.00 60.00 120.00 + 5250 3150 5250 2400 +2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 + 5100 1800 5400 1800 5400 2400 5100 2400 5100 1800 +4 1 -1 0 0 0 10 0.0000 2 75 75 6000 2745 a\001 +4 1 -1 0 0 0 10 0.0000 2 75 75 6000 2445 c\001 +4 1 -1 0 0 0 12 0.0000 2 135 315 5100 5325 exit\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 3300 3075 A\001 +4 1 -1 0 0 0 12 0.0000 2 135 795 3300 4875 condition\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 3300 5100 B\001 +4 0 -1 0 0 0 12 0.0000 2 135 420 6600 3675 stack\001 +4 0 -1 0 0 0 12 0.0000 2 180 750 6600 3225 acceptor/\001 +4 0 -1 0 0 0 12 0.0000 2 180 750 6600 3450 signalled\001 +4 1 -1 0 0 0 12 0.0000 2 135 795 3300 2850 condition\001 +4 1 -1 0 0 0 12 0.0000 2 165 420 6000 1350 entry\001 +4 1 -1 0 0 0 12 0.0000 2 135 495 6000 1575 queue\001 +4 0 -1 0 0 0 12 0.0000 2 135 525 6300 2400 arrival\001 +4 0 -1 0 0 0 12 0.0000 2 135 630 6300 2175 order of\001 +4 1 -1 0 0 0 12 0.0000 2 135 525 5100 3675 shared\001 +4 1 -1 0 0 0 12 0.0000 2 135 735 5100 3975 variables\001 +4 0 0 50 -1 0 11 0.0000 2 165 855 4275 3150 Acceptables\001 Index: doc/proposals/concurrency/ext_monitor.fig.bak =================================================================== --- doc/proposals/concurrency/ext_monitor.fig.bak (revision a1e67ddc023331e04cc5481931be1d0923efc441) +++ doc/proposals/concurrency/ext_monitor.fig.bak (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -0,0 +1,95 @@ +#FIG 3.2 Produced by xfig version 3.2.5c +Landscape +Center +Inches +Letter +100.00 +Single +-2 +1200 2 +5 1 0 1 -1 -1 0 0 -1 0.000 0 1 0 0 3150.000 3450.000 3150 3150 2850 3450 3150 3750 +5 1 0 1 -1 -1 0 0 -1 0.000 0 1 0 0 3150.000 4350.000 3150 4050 2850 4350 3150 4650 +6 5850 1950 6150 2250 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 2100 105 105 6000 2100 6105 2205 +4 1 -1 0 0 0 10 0.0000 2 105 90 6000 2160 d\001 +-6 +6 5850 1650 6150 1950 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 1800 105 105 6000 1800 6105 1905 +4 1 -1 0 0 0 10 0.0000 2 105 90 6000 1860 b\001 +-6 +6 5100 1800 5400 2100 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 1950 105 105 5250 1950 5355 1950 +4 1 -1 0 0 0 10 0.0000 2 105 120 5250 2010 Y\001 +-6 +6 5100 2100 5400 2400 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 2250 105 105 5250 2250 5355 2250 +4 1 -1 0 0 0 10 0.0000 2 105 120 5250 2295 X\001 +-6 +6 3000 5400 7200 5700 +1 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 3150 5550 80 80 3150 5550 3230 5630 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4500 5550 105 105 4500 5550 4605 5655 +1 3 0 1 -1 -1 0 0 4 0.000 1 0.0000 6000 5550 105 105 6000 5550 6105 5655 +4 0 -1 0 0 0 12 0.0000 2 135 1035 4725 5625 blocked task\001 +4 0 -1 0 0 0 12 0.0000 2 135 870 3300 5625 active task\001 +4 0 -1 0 0 0 12 0.0000 2 180 930 6225 5625 routine ptrs\001 +-6 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3300 3600 105 105 3300 3600 3405 3705 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3600 3600 105 105 3600 3600 3705 3705 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6600 3900 105 105 6600 3900 6705 4005 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6900 3900 105 105 6900 3900 7005 4005 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 2700 105 105 6000 2700 6105 2805 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 2400 105 105 6000 2400 6105 2505 +1 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 5100 4575 80 80 5100 4575 5180 4655 +2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 + 4050 2925 5475 2925 5475 3225 4050 3225 4050 2925 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 5850 2850 6075 3000 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3150 3750 3750 3750 3750 4050 3150 4050 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 3150 3450 3750 3450 3900 3675 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 3750 3150 3600 3375 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 3150 4350 3750 4350 3900 4575 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 3750 4050 3600 4275 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3150 4650 3750 4650 3750 4950 4950 4950 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 6450 3750 6300 3975 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 4950 4950 5175 5100 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 9 + 5250 4950 6450 4950 6450 4050 7050 4050 7050 3750 6450 3750 + 6450 2850 6150 2850 6150 1650 +2 2 1 1 -1 -1 0 0 -1 4.000 0 0 0 0 0 5 + 5850 4200 5850 3300 4350 3300 4350 4200 5850 4200 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 5250 2850 5850 2850 5850 1650 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3150 3150 3750 3150 3750 2850 5325 2850 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2 + 1 1 1.00 60.00 120.00 + 7 1 1.00 60.00 120.00 + 5250 3150 5250 2400 +2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 + 5100 1800 5400 1800 5400 2400 5100 2400 5100 1800 +4 0 0 50 -1 0 11 0.0000 2 150 795 4275 3150 Queues Ptr\001 +4 1 -1 0 0 0 10 0.0000 2 75 75 6000 2745 a\001 +4 1 -1 0 0 0 10 0.0000 2 75 75 6000 2445 c\001 +4 1 -1 0 0 0 12 0.0000 2 135 315 5100 5325 exit\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 3300 3075 A\001 +4 1 -1 0 0 0 12 0.0000 2 135 795 3300 4875 condition\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 3300 5100 B\001 +4 0 -1 0 0 0 12 0.0000 2 135 420 6600 3675 stack\001 +4 0 -1 0 0 0 12 0.0000 2 180 750 6600 3225 acceptor/\001 +4 0 -1 0 0 0 12 0.0000 2 180 750 6600 3450 signalled\001 +4 1 -1 0 0 0 12 0.0000 2 135 795 3300 2850 condition\001 +4 1 -1 0 0 0 12 0.0000 2 165 420 6000 1350 entry\001 +4 1 -1 0 0 0 12 0.0000 2 135 495 6000 1575 queue\001 +4 0 -1 0 0 0 12 0.0000 2 135 525 6300 2400 arrival\001 +4 0 -1 0 0 0 12 0.0000 2 135 630 6300 2175 order of\001 +4 1 -1 0 0 0 12 0.0000 2 135 525 5100 3675 shared\001 +4 1 -1 0 0 0 12 0.0000 2 135 735 5100 3975 variables\001 +4 0 0 50 -1 0 11 0.0000 2 165 855 4125 2175 Acceptables\001 Index: doc/proposals/concurrency/glossary.tex =================================================================== --- doc/proposals/concurrency/glossary.tex (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ doc/proposals/concurrency/glossary.tex (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -31,2 +31,38 @@ \textit{Synonyms : Tasks.} } + +\longnewglossaryentry{cfacluster} +{name={cluster}} +{ +TBD... + +\textit{Synonyms : None.} +} + +\longnewglossaryentry{cfacpu} +{name={processor}} +{ +TBD... + +\textit{Synonyms : None.} +} + +\longnewglossaryentry{cfathread} +{name={thread}} +{ +TBD... + +\textit{Synonyms : None.} +} + +\longnewglossaryentry{preemption} +{name={preemption}} +{ +TBD... + +\textit{Synonyms : None.} +} + +\newacronym{tls}{TLS}{Thread Local Storage} +\newacronym{api}{API}{Application Program Interface} +\newacronym{raii}{RAII}{Ressource Acquisition Is Initialization} Index: doc/proposals/concurrency/monitor.fig =================================================================== --- doc/proposals/concurrency/monitor.fig (revision a1e67ddc023331e04cc5481931be1d0923efc441) +++ doc/proposals/concurrency/monitor.fig (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -0,0 +1,101 @@ +#FIG 3.2 Produced by xfig version 3.2.5c +Landscape +Center +Inches +Letter +100.00 +Single +-2 +1200 2 +5 1 0 1 -1 -1 0 0 -1 0.000 0 1 0 0 1500.000 2700.000 1500 2400 1200 2700 1500 3000 +5 1 0 1 -1 -1 0 0 -1 0.000 0 1 0 0 1500.000 3600.000 1500 3300 1200 3600 1500 3900 +6 4200 1200 4500 1500 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4350 1350 105 105 4350 1350 4455 1455 +4 1 -1 0 0 0 10 0.0000 2 105 90 4350 1410 d\001 +-6 +6 4200 900 4500 1200 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4350 1050 105 105 4350 1050 4455 1155 +4 1 -1 0 0 0 10 0.0000 2 105 90 4350 1110 b\001 +-6 +6 2400 1500 2700 1800 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 2550 1650 105 105 2550 1650 2655 1650 +4 1 -1 0 0 0 10 0.0000 2 105 90 2550 1710 b\001 +-6 +6 2400 1800 2700 2100 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 2550 1950 105 105 2550 1950 2655 1950 +4 1 -1 0 0 0 10 0.0000 2 75 75 2550 1995 a\001 +-6 +6 3300 1500 3600 1800 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 3450 1650 105 105 3450 1650 3555 1650 +4 1 -1 0 0 0 10 0.0000 2 105 90 3450 1710 d\001 +-6 +6 1350 4650 5325 4950 +1 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 1500 4800 80 80 1500 4800 1580 4880 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 2850 4800 105 105 2850 4800 2955 4905 +1 3 0 1 -1 -1 0 0 4 0.000 1 0.0000 4350 4800 105 105 4350 4800 4455 4905 +4 0 -1 0 0 0 12 0.0000 2 180 765 4575 4875 duplicate\001 +4 0 -1 0 0 0 12 0.0000 2 135 1035 3075 4875 blocked task\001 +4 0 -1 0 0 0 12 0.0000 2 135 870 1650 4875 active task\001 +-6 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 1650 2850 105 105 1650 2850 1755 2955 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 1950 2850 105 105 1950 2850 2055 2955 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4950 3150 105 105 4950 3150 5055 3255 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 5250 3150 105 105 5250 3150 5355 3255 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4350 1950 105 105 4350 1950 4455 2055 +1 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4350 1650 105 105 4350 1650 4455 1755 +1 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 3450 3825 80 80 3450 3825 3530 3905 +1 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 3450 1950 105 105 3450 1950 3555 1950 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 2400 2100 2625 2250 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 3300 2100 3525 2250 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 4200 2100 4425 2250 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 5 + 1500 2400 2100 2400 2100 2100 2400 2100 2400 1500 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 1500 3000 2100 3000 2100 3300 1500 3300 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 1500 2700 2100 2700 2250 2925 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 2100 2400 1950 2625 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3 + 1500 3600 2100 3600 2250 3825 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 2100 3300 1950 3525 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 1500 3900 2100 3900 2100 4200 3300 4200 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 4800 3000 4650 3225 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2 + 3300 4200 3525 4350 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 3600 1500 3600 2100 4200 2100 4200 900 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4 + 2700 1500 2700 2100 3300 2100 3300 1500 +2 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 9 + 3600 4200 4800 4200 4800 3300 5400 3300 5400 3000 4800 3000 + 4800 2100 4500 2100 4500 900 +2 2 1 1 -1 -1 0 0 -1 4.000 0 0 0 0 0 5 + 4200 3450 4200 2550 2700 2550 2700 3450 4200 3450 +4 1 -1 0 0 0 10 0.0000 2 75 75 4350 1995 a\001 +4 1 -1 0 0 0 10 0.0000 2 75 75 4350 1695 c\001 +4 1 -1 0 0 0 12 0.0000 2 135 315 3450 4575 exit\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 1650 2325 A\001 +4 1 -1 0 0 0 12 0.0000 2 135 795 1650 4125 condition\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 1650 4350 B\001 +4 0 -1 0 0 0 12 0.0000 2 135 420 4950 2925 stack\001 +4 0 -1 0 0 0 12 0.0000 2 180 750 4950 2475 acceptor/\001 +4 0 -1 0 0 0 12 0.0000 2 180 750 4950 2700 signalled\001 +4 1 -1 0 0 0 12 0.0000 2 135 795 1650 2100 condition\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 2550 1425 X\001 +4 1 -1 0 0 0 12 0.0000 2 135 135 3450 1425 Y\001 +4 1 -1 0 0 0 12 0.0000 2 165 420 4350 600 entry\001 +4 1 -1 0 0 0 12 0.0000 2 135 495 4350 825 queue\001 +4 0 -1 0 0 0 12 0.0000 2 135 525 4650 1650 arrival\001 +4 0 -1 0 0 0 12 0.0000 2 135 630 4650 1425 order of\001 +4 1 -1 0 0 0 12 0.0000 2 135 525 3450 2925 shared\001 +4 1 -1 0 0 0 12 0.0000 2 135 735 3450 3225 variables\001 +4 1 -1 0 0 0 12 0.0000 2 120 510 3000 975 mutex\001 +4 1 -1 0 0 0 10 0.0000 2 75 75 3450 1995 c\001 +4 1 -1 0 0 0 12 0.0000 2 135 570 3000 1200 queues\001 Index: doc/proposals/concurrency/version =================================================================== --- doc/proposals/concurrency/version (revision a1e67ddc023331e04cc5481931be1d0923efc441) +++ doc/proposals/concurrency/version (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -0,0 +1,1 @@ +0.4.95 Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ doc/user/user.tex (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Sun Aug 14 08:23:06 2016 -%% Update Count : 1323 +%% Last Modified On : Thu Sep 29 11:50:28 2016 +%% Update Count : 1325 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -33,4 +33,5 @@ \usepackage{textcomp} \usepackage[latin1]{inputenc} + \usepackage{fullpage,times,comment} \usepackage{epic,eepic} @@ -1853,11 +1854,7 @@ case 1: case 2: case 3: ... \end{lstlisting} -still work. +still works. Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments. -<<<<<<< HEAD -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: -======= 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 ©fallthrough©/©fallthru©, e.g.: ->>>>>>> 080615890f586cb9954c252b55cab47f52c25758 \begin{lstlisting} ®choose® ( i ) { Index: src/Parser/lex.cc =================================================================== --- src/Parser/lex.cc (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ src/Parser/lex.cc (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -1469,6 +1469,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Wed Aug 24 13:27:04 2016 - * Update Count : 487 + * Last Modified On : Tue Oct 18 22:19:37 2016 + * Update Count : 488 */ #line 20 "lex.ll" @@ -1517,5 +1517,4 @@ // identifier, GCC: $ in identifier -// quoted identifier // attribute identifier, GCC: $ in identifier // numeric constants, CFA: '_' in constant @@ -1532,5 +1531,5 @@ -#line 1535 "Parser/lex.cc" +#line 1534 "Parser/lex.cc" #define INITIAL 0 @@ -1724,8 +1723,8 @@ register int yy_act; -#line 139 "lex.ll" +#line 136 "lex.ll" /* line directives */ -#line 1730 "Parser/lex.cc" +#line 1729 "Parser/lex.cc" if ( !(yy_init) ) @@ -1824,5 +1823,5 @@ /* rule 1 can match eol */ YY_RULE_SETUP -#line 141 "lex.ll" +#line 138 "lex.ll" { /* " stop highlighting */ @@ -1850,5 +1849,5 @@ /* rule 2 can match eol */ YY_RULE_SETUP -#line 163 "lex.ll" +#line 160 "lex.ll" ; YY_BREAK @@ -1856,5 +1855,5 @@ case 3: YY_RULE_SETUP -#line 166 "lex.ll" +#line 163 "lex.ll" { BEGIN COMMENT; } YY_BREAK @@ -1862,10 +1861,10 @@ /* rule 4 can match eol */ YY_RULE_SETUP -#line 167 "lex.ll" +#line 164 "lex.ll" ; YY_BREAK case 5: YY_RULE_SETUP -#line 168 "lex.ll" +#line 165 "lex.ll" { BEGIN 0; } YY_BREAK @@ -1874,5 +1873,5 @@ /* rule 6 can match eol */ YY_RULE_SETUP -#line 171 "lex.ll" +#line 168 "lex.ll" ; YY_BREAK @@ -1880,10 +1879,10 @@ case 7: YY_RULE_SETUP -#line 174 "lex.ll" +#line 171 "lex.ll" { WHITE_RETURN(' '); } YY_BREAK case 8: YY_RULE_SETUP -#line 175 "lex.ll" +#line 172 "lex.ll" { WHITE_RETURN(' '); } YY_BREAK @@ -1891,5 +1890,5 @@ /* rule 9 can match eol */ YY_RULE_SETUP -#line 176 "lex.ll" +#line 173 "lex.ll" { NEWLINE_RETURN(); } YY_BREAK @@ -1897,465 +1896,465 @@ case 10: YY_RULE_SETUP +#line 176 "lex.ll" +{ KEYWORD_RETURN(ALIGNAS); } // C11 + YY_BREAK +case 11: +YY_RULE_SETUP +#line 177 "lex.ll" +{ KEYWORD_RETURN(ALIGNOF); } // C11 + YY_BREAK +case 12: +YY_RULE_SETUP +#line 178 "lex.ll" +{ KEYWORD_RETURN(ALIGNOF); } // GCC + YY_BREAK +case 13: +YY_RULE_SETUP #line 179 "lex.ll" -{ KEYWORD_RETURN(ALIGNAS); } // C11 - YY_BREAK -case 11: +{ KEYWORD_RETURN(ALIGNOF); } // GCC + YY_BREAK +case 14: YY_RULE_SETUP #line 180 "lex.ll" -{ KEYWORD_RETURN(ALIGNOF); } // C11 - YY_BREAK -case 12: +{ KEYWORD_RETURN(ASM); } + YY_BREAK +case 15: YY_RULE_SETUP #line 181 "lex.ll" -{ KEYWORD_RETURN(ALIGNOF); } // GCC - YY_BREAK -case 13: +{ KEYWORD_RETURN(ASM); } // GCC + YY_BREAK +case 16: YY_RULE_SETUP #line 182 "lex.ll" -{ KEYWORD_RETURN(ALIGNOF); } // GCC - YY_BREAK -case 14: +{ KEYWORD_RETURN(ASM); } // GCC + YY_BREAK +case 17: YY_RULE_SETUP #line 183 "lex.ll" -{ KEYWORD_RETURN(ASM); } - YY_BREAK -case 15: +{ KEYWORD_RETURN(AT); } // CFA + YY_BREAK +case 18: YY_RULE_SETUP #line 184 "lex.ll" -{ KEYWORD_RETURN(ASM); } // GCC - YY_BREAK -case 16: +{ KEYWORD_RETURN(ATOMIC); } // C11 + YY_BREAK +case 19: YY_RULE_SETUP #line 185 "lex.ll" -{ KEYWORD_RETURN(ASM); } // GCC - YY_BREAK -case 17: +{ KEYWORD_RETURN(ATTRIBUTE); } // GCC + YY_BREAK +case 20: YY_RULE_SETUP #line 186 "lex.ll" -{ KEYWORD_RETURN(AT); } // CFA - YY_BREAK -case 18: +{ KEYWORD_RETURN(ATTRIBUTE); } // GCC + YY_BREAK +case 21: YY_RULE_SETUP #line 187 "lex.ll" -{ KEYWORD_RETURN(ATOMIC); } // C11 - YY_BREAK -case 19: +{ KEYWORD_RETURN(AUTO); } + YY_BREAK +case 22: YY_RULE_SETUP #line 188 "lex.ll" -{ KEYWORD_RETURN(ATTRIBUTE); } // GCC - YY_BREAK -case 20: +{ KEYWORD_RETURN(BOOL); } // C99 + YY_BREAK +case 23: YY_RULE_SETUP #line 189 "lex.ll" -{ KEYWORD_RETURN(ATTRIBUTE); } // GCC - YY_BREAK -case 21: +{ KEYWORD_RETURN(BREAK); } + YY_BREAK +case 24: YY_RULE_SETUP #line 190 "lex.ll" -{ KEYWORD_RETURN(AUTO); } - YY_BREAK -case 22: +{ KEYWORD_RETURN(CASE); } + YY_BREAK +case 25: YY_RULE_SETUP #line 191 "lex.ll" -{ KEYWORD_RETURN(BOOL); } // C99 - YY_BREAK -case 23: +{ KEYWORD_RETURN(CATCH); } // CFA + YY_BREAK +case 26: YY_RULE_SETUP #line 192 "lex.ll" -{ KEYWORD_RETURN(BREAK); } - YY_BREAK -case 24: +{ KEYWORD_RETURN(CATCHRESUME); } // CFA + YY_BREAK +case 27: YY_RULE_SETUP #line 193 "lex.ll" -{ KEYWORD_RETURN(CASE); } - YY_BREAK -case 25: +{ KEYWORD_RETURN(CHAR); } + YY_BREAK +case 28: YY_RULE_SETUP #line 194 "lex.ll" -{ KEYWORD_RETURN(CATCH); } // CFA - YY_BREAK -case 26: +{ KEYWORD_RETURN(CHOOSE); } // CFA + YY_BREAK +case 29: YY_RULE_SETUP #line 195 "lex.ll" -{ KEYWORD_RETURN(CATCHRESUME); } // CFA - YY_BREAK -case 27: +{ KEYWORD_RETURN(COMPLEX); } // C99 + YY_BREAK +case 30: YY_RULE_SETUP #line 196 "lex.ll" -{ KEYWORD_RETURN(CHAR); } - YY_BREAK -case 28: +{ KEYWORD_RETURN(COMPLEX); } // GCC + YY_BREAK +case 31: YY_RULE_SETUP #line 197 "lex.ll" -{ KEYWORD_RETURN(CHOOSE); } // CFA - YY_BREAK -case 29: +{ KEYWORD_RETURN(COMPLEX); } // GCC + YY_BREAK +case 32: YY_RULE_SETUP #line 198 "lex.ll" -{ KEYWORD_RETURN(COMPLEX); } // C99 - YY_BREAK -case 30: +{ KEYWORD_RETURN(CONST); } + YY_BREAK +case 33: YY_RULE_SETUP #line 199 "lex.ll" -{ KEYWORD_RETURN(COMPLEX); } // GCC - YY_BREAK -case 31: +{ KEYWORD_RETURN(CONST); } // GCC + YY_BREAK +case 34: YY_RULE_SETUP #line 200 "lex.ll" -{ KEYWORD_RETURN(COMPLEX); } // GCC - YY_BREAK -case 32: +{ KEYWORD_RETURN(CONST); } // GCC + YY_BREAK +case 35: YY_RULE_SETUP #line 201 "lex.ll" -{ KEYWORD_RETURN(CONST); } - YY_BREAK -case 33: +{ KEYWORD_RETURN(CONTINUE); } + YY_BREAK +case 36: YY_RULE_SETUP #line 202 "lex.ll" -{ KEYWORD_RETURN(CONST); } // GCC - YY_BREAK -case 34: +{ KEYWORD_RETURN(DEFAULT); } + YY_BREAK +case 37: YY_RULE_SETUP #line 203 "lex.ll" -{ KEYWORD_RETURN(CONST); } // GCC - YY_BREAK -case 35: +{ KEYWORD_RETURN(DISABLE); } // CFA + YY_BREAK +case 38: YY_RULE_SETUP #line 204 "lex.ll" -{ KEYWORD_RETURN(CONTINUE); } - YY_BREAK -case 36: +{ KEYWORD_RETURN(DO); } + YY_BREAK +case 39: YY_RULE_SETUP #line 205 "lex.ll" -{ KEYWORD_RETURN(DEFAULT); } - YY_BREAK -case 37: +{ KEYWORD_RETURN(DOUBLE); } + YY_BREAK +case 40: YY_RULE_SETUP #line 206 "lex.ll" -{ KEYWORD_RETURN(DISABLE); } // CFA - YY_BREAK -case 38: +{ KEYWORD_RETURN(DTYPE); } // CFA + YY_BREAK +case 41: YY_RULE_SETUP #line 207 "lex.ll" -{ KEYWORD_RETURN(DO); } - YY_BREAK -case 39: +{ KEYWORD_RETURN(ELSE); } + YY_BREAK +case 42: YY_RULE_SETUP #line 208 "lex.ll" -{ KEYWORD_RETURN(DOUBLE); } - YY_BREAK -case 40: +{ KEYWORD_RETURN(ENABLE); } // CFA + YY_BREAK +case 43: YY_RULE_SETUP #line 209 "lex.ll" -{ KEYWORD_RETURN(DTYPE); } // CFA - YY_BREAK -case 41: +{ KEYWORD_RETURN(ENUM); } + YY_BREAK +case 44: YY_RULE_SETUP #line 210 "lex.ll" -{ KEYWORD_RETURN(ELSE); } - YY_BREAK -case 42: +{ KEYWORD_RETURN(EXTENSION); } // GCC + YY_BREAK +case 45: YY_RULE_SETUP #line 211 "lex.ll" -{ KEYWORD_RETURN(ENABLE); } // CFA - YY_BREAK -case 43: +{ KEYWORD_RETURN(EXTERN); } + YY_BREAK +case 46: YY_RULE_SETUP #line 212 "lex.ll" -{ KEYWORD_RETURN(ENUM); } - YY_BREAK -case 44: +{ KEYWORD_RETURN(FALLTHRU); } // CFA + YY_BREAK +case 47: YY_RULE_SETUP #line 213 "lex.ll" -{ KEYWORD_RETURN(EXTENSION); } // GCC - YY_BREAK -case 45: +{ KEYWORD_RETURN(FALLTHRU); } // CFA + YY_BREAK +case 48: YY_RULE_SETUP #line 214 "lex.ll" -{ KEYWORD_RETURN(EXTERN); } - YY_BREAK -case 46: +{ KEYWORD_RETURN(FINALLY); } // CFA + YY_BREAK +case 49: YY_RULE_SETUP #line 215 "lex.ll" -{ KEYWORD_RETURN(FALLTHRU); } // CFA - YY_BREAK -case 47: +{ KEYWORD_RETURN(FLOAT); } + YY_BREAK +case 50: YY_RULE_SETUP #line 216 "lex.ll" -{ KEYWORD_RETURN(FALLTHRU); } // CFA - YY_BREAK -case 48: +{ KEYWORD_RETURN(FLOAT); } // GCC + YY_BREAK +case 51: YY_RULE_SETUP #line 217 "lex.ll" -{ KEYWORD_RETURN(FINALLY); } // CFA - YY_BREAK -case 49: +{ KEYWORD_RETURN(FOR); } + YY_BREAK +case 52: YY_RULE_SETUP #line 218 "lex.ll" -{ KEYWORD_RETURN(FLOAT); } - YY_BREAK -case 50: +{ KEYWORD_RETURN(FORALL); } // CFA + YY_BREAK +case 53: YY_RULE_SETUP #line 219 "lex.ll" -{ KEYWORD_RETURN(FLOAT); } // GCC - YY_BREAK -case 51: +{ KEYWORD_RETURN(FORTRAN); } + YY_BREAK +case 54: YY_RULE_SETUP #line 220 "lex.ll" -{ KEYWORD_RETURN(FOR); } - YY_BREAK -case 52: +{ KEYWORD_RETURN(FTYPE); } // CFA + YY_BREAK +case 55: YY_RULE_SETUP #line 221 "lex.ll" -{ KEYWORD_RETURN(FORALL); } // CFA - YY_BREAK -case 53: +{ KEYWORD_RETURN(GENERIC); } // C11 + YY_BREAK +case 56: YY_RULE_SETUP #line 222 "lex.ll" -{ KEYWORD_RETURN(FORTRAN); } - YY_BREAK -case 54: +{ KEYWORD_RETURN(GOTO); } + YY_BREAK +case 57: YY_RULE_SETUP #line 223 "lex.ll" -{ KEYWORD_RETURN(FTYPE); } // CFA - YY_BREAK -case 55: +{ KEYWORD_RETURN(IF); } + YY_BREAK +case 58: YY_RULE_SETUP #line 224 "lex.ll" -{ KEYWORD_RETURN(GENERIC); } // C11 - YY_BREAK -case 56: +{ KEYWORD_RETURN(IMAGINARY); } // C99 + YY_BREAK +case 59: YY_RULE_SETUP #line 225 "lex.ll" -{ KEYWORD_RETURN(GOTO); } - YY_BREAK -case 57: +{ KEYWORD_RETURN(IMAGINARY); } // GCC + YY_BREAK +case 60: YY_RULE_SETUP #line 226 "lex.ll" -{ KEYWORD_RETURN(IF); } - YY_BREAK -case 58: +{ KEYWORD_RETURN(IMAGINARY); } // GCC + YY_BREAK +case 61: YY_RULE_SETUP #line 227 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // C99 - YY_BREAK -case 59: +{ KEYWORD_RETURN(INLINE); } // C99 + YY_BREAK +case 62: YY_RULE_SETUP #line 228 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // GCC - YY_BREAK -case 60: +{ KEYWORD_RETURN(INLINE); } // GCC + YY_BREAK +case 63: YY_RULE_SETUP #line 229 "lex.ll" -{ KEYWORD_RETURN(IMAGINARY); } // GCC - YY_BREAK -case 61: +{ KEYWORD_RETURN(INLINE); } // GCC + YY_BREAK +case 64: YY_RULE_SETUP #line 230 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // C99 - YY_BREAK -case 62: +{ KEYWORD_RETURN(INT); } + YY_BREAK +case 65: YY_RULE_SETUP #line 231 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // GCC - YY_BREAK -case 63: +{ KEYWORD_RETURN(INT); } // GCC + YY_BREAK +case 66: YY_RULE_SETUP #line 232 "lex.ll" -{ KEYWORD_RETURN(INLINE); } // GCC - YY_BREAK -case 64: +{ KEYWORD_RETURN(LABEL); } // GCC + YY_BREAK +case 67: YY_RULE_SETUP #line 233 "lex.ll" -{ KEYWORD_RETURN(INT); } - YY_BREAK -case 65: +{ KEYWORD_RETURN(LONG); } + YY_BREAK +case 68: YY_RULE_SETUP #line 234 "lex.ll" -{ KEYWORD_RETURN(INT); } // GCC - YY_BREAK -case 66: +{ KEYWORD_RETURN(LVALUE); } // CFA + YY_BREAK +case 69: YY_RULE_SETUP #line 235 "lex.ll" -{ KEYWORD_RETURN(LABEL); } // GCC - YY_BREAK -case 67: +{ KEYWORD_RETURN(NORETURN); } // C11 + YY_BREAK +case 70: YY_RULE_SETUP #line 236 "lex.ll" -{ KEYWORD_RETURN(LONG); } - YY_BREAK -case 68: +{ KEYWORD_RETURN(OFFSETOF); } // GCC + YY_BREAK +case 71: YY_RULE_SETUP #line 237 "lex.ll" -{ KEYWORD_RETURN(LVALUE); } // CFA - YY_BREAK -case 69: +{ KEYWORD_RETURN(OTYPE); } // CFA + YY_BREAK +case 72: YY_RULE_SETUP #line 238 "lex.ll" -{ KEYWORD_RETURN(NORETURN); } // C11 - YY_BREAK -case 70: +{ KEYWORD_RETURN(REGISTER); } + YY_BREAK +case 73: YY_RULE_SETUP #line 239 "lex.ll" -{ KEYWORD_RETURN(OFFSETOF); } // GCC - YY_BREAK -case 71: +{ KEYWORD_RETURN(RESTRICT); } // C99 + YY_BREAK +case 74: YY_RULE_SETUP #line 240 "lex.ll" -{ KEYWORD_RETURN(OTYPE); } // CFA - YY_BREAK -case 72: +{ KEYWORD_RETURN(RESTRICT); } // GCC + YY_BREAK +case 75: YY_RULE_SETUP #line 241 "lex.ll" -{ KEYWORD_RETURN(REGISTER); } - YY_BREAK -case 73: +{ KEYWORD_RETURN(RESTRICT); } // GCC + YY_BREAK +case 76: YY_RULE_SETUP #line 242 "lex.ll" -{ KEYWORD_RETURN(RESTRICT); } // C99 - YY_BREAK -case 74: +{ KEYWORD_RETURN(RETURN); } + YY_BREAK +case 77: YY_RULE_SETUP #line 243 "lex.ll" -{ KEYWORD_RETURN(RESTRICT); } // GCC - YY_BREAK -case 75: +{ KEYWORD_RETURN(SHORT); } + YY_BREAK +case 78: YY_RULE_SETUP #line 244 "lex.ll" -{ KEYWORD_RETURN(RESTRICT); } // GCC - YY_BREAK -case 76: +{ KEYWORD_RETURN(SIGNED); } + YY_BREAK +case 79: YY_RULE_SETUP #line 245 "lex.ll" -{ KEYWORD_RETURN(RETURN); } - YY_BREAK -case 77: +{ KEYWORD_RETURN(SIGNED); } // GCC + YY_BREAK +case 80: YY_RULE_SETUP #line 246 "lex.ll" -{ KEYWORD_RETURN(SHORT); } - YY_BREAK -case 78: +{ KEYWORD_RETURN(SIGNED); } // GCC + YY_BREAK +case 81: YY_RULE_SETUP #line 247 "lex.ll" -{ KEYWORD_RETURN(SIGNED); } - YY_BREAK -case 79: +{ KEYWORD_RETURN(SIZEOF); } + YY_BREAK +case 82: YY_RULE_SETUP #line 248 "lex.ll" -{ KEYWORD_RETURN(SIGNED); } // GCC - YY_BREAK -case 80: +{ KEYWORD_RETURN(STATIC); } + YY_BREAK +case 83: YY_RULE_SETUP #line 249 "lex.ll" -{ KEYWORD_RETURN(SIGNED); } // GCC - YY_BREAK -case 81: +{ KEYWORD_RETURN(STATICASSERT); } // C11 + YY_BREAK +case 84: YY_RULE_SETUP #line 250 "lex.ll" -{ KEYWORD_RETURN(SIZEOF); } - YY_BREAK -case 82: +{ KEYWORD_RETURN(STRUCT); } + YY_BREAK +case 85: YY_RULE_SETUP #line 251 "lex.ll" -{ KEYWORD_RETURN(STATIC); } - YY_BREAK -case 83: +{ KEYWORD_RETURN(SWITCH); } + YY_BREAK +case 86: YY_RULE_SETUP #line 252 "lex.ll" -{ KEYWORD_RETURN(STATICASSERT); } // C11 - YY_BREAK -case 84: +{ KEYWORD_RETURN(THREADLOCAL); } // C11 + YY_BREAK +case 87: YY_RULE_SETUP #line 253 "lex.ll" -{ KEYWORD_RETURN(STRUCT); } - YY_BREAK -case 85: +{ KEYWORD_RETURN(THROW); } // CFA + YY_BREAK +case 88: YY_RULE_SETUP #line 254 "lex.ll" -{ KEYWORD_RETURN(SWITCH); } - YY_BREAK -case 86: +{ KEYWORD_RETURN(THROWRESUME); } // CFA + YY_BREAK +case 89: YY_RULE_SETUP #line 255 "lex.ll" -{ KEYWORD_RETURN(THREADLOCAL); } // C11 - YY_BREAK -case 87: +{ KEYWORD_RETURN(TRAIT); } // CFA + YY_BREAK +case 90: YY_RULE_SETUP #line 256 "lex.ll" -{ KEYWORD_RETURN(THROW); } // CFA - YY_BREAK -case 88: +{ KEYWORD_RETURN(TRY); } // CFA + YY_BREAK +case 91: YY_RULE_SETUP #line 257 "lex.ll" -{ KEYWORD_RETURN(THROWRESUME); } // CFA - YY_BREAK -case 89: +{ KEYWORD_RETURN(TYPEDEF); } + YY_BREAK +case 92: YY_RULE_SETUP #line 258 "lex.ll" -{ KEYWORD_RETURN(TRAIT); } // CFA - YY_BREAK -case 90: +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 93: YY_RULE_SETUP #line 259 "lex.ll" -{ KEYWORD_RETURN(TRY); } // CFA - YY_BREAK -case 91: +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 94: YY_RULE_SETUP #line 260 "lex.ll" -{ KEYWORD_RETURN(TYPEDEF); } - YY_BREAK -case 92: +{ KEYWORD_RETURN(TYPEOF); } // GCC + YY_BREAK +case 95: YY_RULE_SETUP #line 261 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 93: +{ KEYWORD_RETURN(UNION); } + YY_BREAK +case 96: YY_RULE_SETUP #line 262 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 94: +{ KEYWORD_RETURN(UNSIGNED); } + YY_BREAK +case 97: YY_RULE_SETUP #line 263 "lex.ll" -{ KEYWORD_RETURN(TYPEOF); } // GCC - YY_BREAK -case 95: +{ KEYWORD_RETURN(VALIST); } // GCC + YY_BREAK +case 98: YY_RULE_SETUP #line 264 "lex.ll" -{ KEYWORD_RETURN(UNION); } - YY_BREAK -case 96: +{ KEYWORD_RETURN(VOID); } + YY_BREAK +case 99: YY_RULE_SETUP #line 265 "lex.ll" -{ KEYWORD_RETURN(UNSIGNED); } - YY_BREAK -case 97: +{ KEYWORD_RETURN(VOLATILE); } + YY_BREAK +case 100: YY_RULE_SETUP #line 266 "lex.ll" -{ KEYWORD_RETURN(VALIST); } // GCC - YY_BREAK -case 98: +{ KEYWORD_RETURN(VOLATILE); } // GCC + YY_BREAK +case 101: YY_RULE_SETUP #line 267 "lex.ll" -{ KEYWORD_RETURN(VOID); } - YY_BREAK -case 99: +{ KEYWORD_RETURN(VOLATILE); } // GCC + YY_BREAK +case 102: YY_RULE_SETUP #line 268 "lex.ll" -{ KEYWORD_RETURN(VOLATILE); } - YY_BREAK -case 100: -YY_RULE_SETUP -#line 269 "lex.ll" -{ KEYWORD_RETURN(VOLATILE); } // GCC - YY_BREAK -case 101: -YY_RULE_SETUP -#line 270 "lex.ll" -{ KEYWORD_RETURN(VOLATILE); } // GCC - YY_BREAK -case 102: -YY_RULE_SETUP -#line 271 "lex.ll" { KEYWORD_RETURN(WHILE); } YY_BREAK @@ -2363,25 +2362,25 @@ case 103: YY_RULE_SETUP +#line 271 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 104: +YY_RULE_SETUP +#line 272 "lex.ll" +{ ATTRIBUTE_RETURN(); } + YY_BREAK +case 105: +YY_RULE_SETUP +#line 273 "lex.ll" +{ BEGIN BKQUOTE; } + YY_BREAK +case 106: +YY_RULE_SETUP #line 274 "lex.ll" { IDENTIFIER_RETURN(); } YY_BREAK -case 104: +case 107: YY_RULE_SETUP #line 275 "lex.ll" -{ ATTRIBUTE_RETURN(); } - YY_BREAK -case 105: -YY_RULE_SETUP -#line 276 "lex.ll" -{ BEGIN BKQUOTE; } - YY_BREAK -case 106: -YY_RULE_SETUP -#line 277 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 107: -YY_RULE_SETUP -#line 278 "lex.ll" { BEGIN 0; } YY_BREAK @@ -2389,35 +2388,35 @@ case 108: YY_RULE_SETUP +#line 278 "lex.ll" +{ NUMERIC_RETURN(ZERO); } // CFA + YY_BREAK +case 109: +YY_RULE_SETUP +#line 279 "lex.ll" +{ NUMERIC_RETURN(ONE); } // CFA + YY_BREAK +case 110: +YY_RULE_SETUP +#line 280 "lex.ll" +{ NUMERIC_RETURN(INTEGERconstant); } + YY_BREAK +case 111: +YY_RULE_SETUP #line 281 "lex.ll" -{ NUMERIC_RETURN(ZERO); } // CFA - YY_BREAK -case 109: +{ NUMERIC_RETURN(INTEGERconstant); } + YY_BREAK +case 112: YY_RULE_SETUP #line 282 "lex.ll" -{ NUMERIC_RETURN(ONE); } // CFA - YY_BREAK -case 110: +{ NUMERIC_RETURN(INTEGERconstant); } + YY_BREAK +case 113: YY_RULE_SETUP #line 283 "lex.ll" -{ NUMERIC_RETURN(INTEGERconstant); } - YY_BREAK -case 111: +{ NUMERIC_RETURN(FLOATINGconstant); } + YY_BREAK +case 114: YY_RULE_SETUP #line 284 "lex.ll" -{ NUMERIC_RETURN(INTEGERconstant); } - YY_BREAK -case 112: -YY_RULE_SETUP -#line 285 "lex.ll" -{ NUMERIC_RETURN(INTEGERconstant); } - YY_BREAK -case 113: -YY_RULE_SETUP -#line 286 "lex.ll" -{ NUMERIC_RETURN(FLOATINGconstant); } - YY_BREAK -case 114: -YY_RULE_SETUP -#line 287 "lex.ll" { NUMERIC_RETURN(FLOATINGconstant); } YY_BREAK @@ -2425,10 +2424,10 @@ case 115: YY_RULE_SETUP -#line 290 "lex.ll" +#line 287 "lex.ll" { BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); } YY_BREAK case 116: YY_RULE_SETUP -#line 291 "lex.ll" +#line 288 "lex.ll" { strtext->append( yytext, yyleng ); } YY_BREAK @@ -2436,5 +2435,5 @@ /* rule 117 can match eol */ YY_RULE_SETUP -#line 292 "lex.ll" +#line 289 "lex.ll" { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); } YY_BREAK @@ -2443,10 +2442,10 @@ case 118: YY_RULE_SETUP -#line 296 "lex.ll" +#line 293 "lex.ll" { BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); } YY_BREAK case 119: YY_RULE_SETUP -#line 297 "lex.ll" +#line 294 "lex.ll" { strtext->append( yytext, yyleng ); } YY_BREAK @@ -2454,5 +2453,5 @@ /* rule 120 can match eol */ YY_RULE_SETUP -#line 298 "lex.ll" +#line 295 "lex.ll" { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); } YY_BREAK @@ -2461,5 +2460,5 @@ case 121: YY_RULE_SETUP -#line 302 "lex.ll" +#line 299 "lex.ll" { rm_underscore(); strtext->append( yytext, yyleng ); } YY_BREAK @@ -2467,10 +2466,10 @@ /* rule 122 can match eol */ YY_RULE_SETUP -#line 303 "lex.ll" +#line 300 "lex.ll" {} // continuation (ALSO HANDLED BY CPP) YY_BREAK case 123: YY_RULE_SETUP -#line 304 "lex.ll" +#line 301 "lex.ll" { strtext->append( yytext, yyleng ); } // unknown escape character YY_BREAK @@ -2478,55 +2477,55 @@ case 124: YY_RULE_SETUP +#line 304 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 125: +YY_RULE_SETUP +#line 305 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 126: +YY_RULE_SETUP +#line 306 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 127: +YY_RULE_SETUP #line 307 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 125: +case 128: YY_RULE_SETUP #line 308 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 126: +case 129: YY_RULE_SETUP #line 309 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 127: +case 130: YY_RULE_SETUP #line 310 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 128: +{ ASCIIOP_RETURN(); } // also operator + YY_BREAK +case 131: YY_RULE_SETUP #line 311 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 129: +case 132: YY_RULE_SETUP #line 312 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 130: +case 133: YY_RULE_SETUP #line 313 "lex.ll" { ASCIIOP_RETURN(); } // also operator YY_BREAK -case 131: +case 134: YY_RULE_SETUP #line 314 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 132: -YY_RULE_SETUP -#line 315 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 133: -YY_RULE_SETUP -#line 316 "lex.ll" -{ ASCIIOP_RETURN(); } // also operator - YY_BREAK -case 134: -YY_RULE_SETUP -#line 317 "lex.ll" { NAMEDOP_RETURN(ELLIPSIS); } YY_BREAK @@ -2534,20 +2533,20 @@ case 135: YY_RULE_SETUP +#line 317 "lex.ll" +{ RETURN_VAL('['); } + YY_BREAK +case 136: +YY_RULE_SETUP +#line 318 "lex.ll" +{ RETURN_VAL(']'); } + YY_BREAK +case 137: +YY_RULE_SETUP +#line 319 "lex.ll" +{ RETURN_VAL('{'); } + YY_BREAK +case 138: +YY_RULE_SETUP #line 320 "lex.ll" -{ RETURN_VAL('['); } - YY_BREAK -case 136: -YY_RULE_SETUP -#line 321 "lex.ll" -{ RETURN_VAL(']'); } - YY_BREAK -case 137: -YY_RULE_SETUP -#line 322 "lex.ll" -{ RETURN_VAL('{'); } - YY_BREAK -case 138: -YY_RULE_SETUP -#line 323 "lex.ll" { RETURN_VAL('}'); } YY_BREAK @@ -2555,180 +2554,180 @@ case 139: YY_RULE_SETUP +#line 323 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 140: +YY_RULE_SETUP +#line 324 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 141: +YY_RULE_SETUP +#line 325 "lex.ll" +{ ASCIIOP_RETURN(); } + YY_BREAK +case 142: +YY_RULE_SETUP #line 326 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 140: +case 143: YY_RULE_SETUP #line 327 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 141: +case 144: YY_RULE_SETUP #line 328 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 142: +case 145: YY_RULE_SETUP #line 329 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 143: +case 146: YY_RULE_SETUP #line 330 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 144: +case 147: YY_RULE_SETUP #line 331 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 145: +case 148: YY_RULE_SETUP #line 332 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 146: +case 149: YY_RULE_SETUP #line 333 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 147: +case 150: YY_RULE_SETUP #line 334 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 148: +case 151: YY_RULE_SETUP #line 335 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 149: +case 152: YY_RULE_SETUP #line 336 "lex.ll" { ASCIIOP_RETURN(); } YY_BREAK -case 150: -YY_RULE_SETUP -#line 337 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 151: +case 153: YY_RULE_SETUP #line 338 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 152: +{ NAMEDOP_RETURN(ICR); } + YY_BREAK +case 154: YY_RULE_SETUP #line 339 "lex.ll" -{ ASCIIOP_RETURN(); } - YY_BREAK -case 153: +{ NAMEDOP_RETURN(DECR); } + YY_BREAK +case 155: +YY_RULE_SETUP +#line 340 "lex.ll" +{ NAMEDOP_RETURN(EQ); } + YY_BREAK +case 156: YY_RULE_SETUP #line 341 "lex.ll" -{ NAMEDOP_RETURN(ICR); } - YY_BREAK -case 154: +{ NAMEDOP_RETURN(NE); } + YY_BREAK +case 157: YY_RULE_SETUP #line 342 "lex.ll" -{ NAMEDOP_RETURN(DECR); } - YY_BREAK -case 155: +{ NAMEDOP_RETURN(LS); } + YY_BREAK +case 158: YY_RULE_SETUP #line 343 "lex.ll" -{ NAMEDOP_RETURN(EQ); } - YY_BREAK -case 156: +{ NAMEDOP_RETURN(RS); } + YY_BREAK +case 159: YY_RULE_SETUP #line 344 "lex.ll" -{ NAMEDOP_RETURN(NE); } - YY_BREAK -case 157: +{ NAMEDOP_RETURN(LE); } + YY_BREAK +case 160: YY_RULE_SETUP #line 345 "lex.ll" -{ NAMEDOP_RETURN(LS); } - YY_BREAK -case 158: +{ NAMEDOP_RETURN(GE); } + YY_BREAK +case 161: YY_RULE_SETUP #line 346 "lex.ll" -{ NAMEDOP_RETURN(RS); } - YY_BREAK -case 159: +{ NAMEDOP_RETURN(ANDAND); } + YY_BREAK +case 162: YY_RULE_SETUP #line 347 "lex.ll" -{ NAMEDOP_RETURN(LE); } - YY_BREAK -case 160: +{ NAMEDOP_RETURN(OROR); } + YY_BREAK +case 163: YY_RULE_SETUP #line 348 "lex.ll" -{ NAMEDOP_RETURN(GE); } - YY_BREAK -case 161: +{ NAMEDOP_RETURN(ARROW); } + YY_BREAK +case 164: YY_RULE_SETUP #line 349 "lex.ll" -{ NAMEDOP_RETURN(ANDAND); } - YY_BREAK -case 162: +{ NAMEDOP_RETURN(PLUSassign); } + YY_BREAK +case 165: YY_RULE_SETUP #line 350 "lex.ll" -{ NAMEDOP_RETURN(OROR); } - YY_BREAK -case 163: +{ NAMEDOP_RETURN(MINUSassign); } + YY_BREAK +case 166: YY_RULE_SETUP #line 351 "lex.ll" -{ NAMEDOP_RETURN(ARROW); } - YY_BREAK -case 164: +{ NAMEDOP_RETURN(MULTassign); } + YY_BREAK +case 167: YY_RULE_SETUP #line 352 "lex.ll" -{ NAMEDOP_RETURN(PLUSassign); } - YY_BREAK -case 165: +{ NAMEDOP_RETURN(DIVassign); } + YY_BREAK +case 168: YY_RULE_SETUP #line 353 "lex.ll" -{ NAMEDOP_RETURN(MINUSassign); } - YY_BREAK -case 166: +{ NAMEDOP_RETURN(MODassign); } + YY_BREAK +case 169: YY_RULE_SETUP #line 354 "lex.ll" -{ NAMEDOP_RETURN(MULTassign); } - YY_BREAK -case 167: +{ NAMEDOP_RETURN(ANDassign); } + YY_BREAK +case 170: YY_RULE_SETUP #line 355 "lex.ll" -{ NAMEDOP_RETURN(DIVassign); } - YY_BREAK -case 168: +{ NAMEDOP_RETURN(ORassign); } + YY_BREAK +case 171: YY_RULE_SETUP #line 356 "lex.ll" -{ NAMEDOP_RETURN(MODassign); } - YY_BREAK -case 169: +{ NAMEDOP_RETURN(ERassign); } + YY_BREAK +case 172: YY_RULE_SETUP #line 357 "lex.ll" -{ NAMEDOP_RETURN(ANDassign); } - YY_BREAK -case 170: +{ NAMEDOP_RETURN(LSassign); } + YY_BREAK +case 173: YY_RULE_SETUP #line 358 "lex.ll" -{ NAMEDOP_RETURN(ORassign); } - YY_BREAK -case 171: -YY_RULE_SETUP -#line 359 "lex.ll" -{ NAMEDOP_RETURN(ERassign); } - YY_BREAK -case 172: +{ NAMEDOP_RETURN(RSassign); } + YY_BREAK +case 174: YY_RULE_SETUP #line 360 "lex.ll" -{ NAMEDOP_RETURN(LSassign); } - YY_BREAK -case 173: -YY_RULE_SETUP -#line 361 "lex.ll" -{ NAMEDOP_RETURN(RSassign); } - YY_BREAK -case 174: -YY_RULE_SETUP -#line 363 "lex.ll" { NAMEDOP_RETURN(ATassign); } // CFA YY_BREAK @@ -2736,20 +2735,20 @@ case 175: YY_RULE_SETUP +#line 363 "lex.ll" +{ IDENTIFIER_RETURN(); } // unary + YY_BREAK +case 176: +YY_RULE_SETUP +#line 364 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 177: +YY_RULE_SETUP +#line 365 "lex.ll" +{ IDENTIFIER_RETURN(); } + YY_BREAK +case 178: +YY_RULE_SETUP #line 366 "lex.ll" -{ IDENTIFIER_RETURN(); } // unary - YY_BREAK -case 176: -YY_RULE_SETUP -#line 367 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 177: -YY_RULE_SETUP -#line 368 "lex.ll" -{ IDENTIFIER_RETURN(); } - YY_BREAK -case 178: -YY_RULE_SETUP -#line 369 "lex.ll" { IDENTIFIER_RETURN(); } // binary YY_BREAK @@ -2782,5 +2781,5 @@ case 179: YY_RULE_SETUP -#line 396 "lex.ll" +#line 393 "lex.ll" { // 1 or 2 character unary operator ? @@ -2797,13 +2796,13 @@ case 180: YY_RULE_SETUP -#line 408 "lex.ll" +#line 405 "lex.ll" { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); } YY_BREAK case 181: YY_RULE_SETUP -#line 410 "lex.ll" +#line 407 "lex.ll" ECHO; YY_BREAK -#line 2808 "Parser/lex.cc" +#line 2807 "Parser/lex.cc" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(COMMENT): @@ -3780,5 +3779,5 @@ #define YYTABLES_NAME "yytables" -#line 410 "lex.ll" +#line 407 "lex.ll" Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ src/Parser/lex.ll (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Wed Aug 24 13:27:04 2016 - * Update Count : 487 + * Last Modified On : Tue Oct 18 22:19:37 2016 + * Update Count : 488 */ @@ -71,7 +71,4 @@ // identifier, GCC: $ in identifier identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})* - - // quoted identifier -quoted_identifier "`"{identifier}"`" // attribute identifier, GCC: $ in identifier Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ src/Parser/parser.cc (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -1027,76 +1027,76 @@ 357, 359, 361, 366, 367, 373, 377, 379, 381, 383, 385, 387, 389, 391, 393, 402, 403, 409, 410, 414, - 415, 419, 422, 424, 426, 428, 433, 435, 440, 443, - 445, 447, 452, 465, 467, 469, 471, 473, 475, 477, - 479, 481, 483, 485, 492, 493, 499, 500, 501, 502, - 506, 507, 509, 514, 515, 517, 519, 524, 525, 527, - 532, 533, 535, 540, 541, 543, 545, 547, 552, 553, - 555, 560, 561, 566, 567, 572, 573, 578, 579, 584, - 585, 590, 591, 594, 596, 601, 606, 607, 609, 615, - 616, 620, 621, 622, 623, 624, 625, 626, 627, 628, - 629, 630, 631, 637, 639, 641, 643, 648, 649, 654, - 655, 661, 662, 668, 669, 670, 671, 672, 673, 674, - 675, 676, 686, 693, 695, 705, 706, 711, 713, 719, - 721, 725, 726, 731, 736, 739, 741, 743, 753, 755, - 766, 767, 769, 773, 775, 779, 780, 785, 786, 790, - 795, 796, 800, 802, 808, 809, 813, 815, 817, 819, - 825, 826, 830, 832, 837, 839, 841, 846, 848, 853, - 855, 859, 862, 866, 869, 873, 875, 877, 879, 884, - 886, 888, 893, 895, 897, 899, 901, 906, 908, 910, - 912, 917, 929, 930, 935, 937, 942, 946, 948, 950, - 952, 954, 960, 961, 967, 968, 972, 973, 978, 980, - 986, 987, 989, 994, 999, 1009, 1011, 1015, 1016, 1021, - 1023, 1027, 1028, 1032, 1034, 1038, 1039, 1043, 1044, 1048, - 1049, 1064, 1065, 1066, 1067, 1068, 1072, 1077, 1084, 1094, - 1099, 1104, 1112, 1117, 1122, 1127, 1132, 1140, 1162, 1167, - 1174, 1176, 1183, 1188, 1193, 1204, 1209, 1214, 1219, 1224, - 1233, 1238, 1246, 1247, 1248, 1249, 1255, 1260, 1268, 1269, - 1270, 1271, 1275, 1276, 1277, 1278, 1283, 1284, 1293, 1294, - 1299, 1300, 1305, 1307, 1309, 1311, 1313, 1316, 1315, 1327, - 1328, 1330, 1340, 1341, 1346, 1348, 1350, 1352, 1354, 1357, - 1359, 1362, 1367, 1369, 1371, 1373, 1375, 1377, 1379, 1381, - 1383, 1385, 1387, 1389, 1391, 1397, 1398, 1400, 1402, 1404, - 1409, 1410, 1416, 1417, 1419, 1421, 1426, 1428, 1430, 1432, - 1437, 1438, 1440, 1442, 1447, 1448, 1450, 1455, 1456, 1458, - 1460, 1465, 1467, 1469, 1474, 1475, 1479, 1481, 1487, 1486, - 1490, 1492, 1497, 1499, 1505, 1506, 1511, 1512, 1514, 1515, - 1524, 1525, 1527, 1529, 1534, 1536, 1542, 1543, 1545, 1548, - 1551, 1556, 1557, 1562, 1567, 1571, 1573, 1579, 1578, 1585, - 1587, 1593, 1594, 1602, 1603, 1607, 1608, 1609, 1611, 1613, - 1620, 1621, 1623, 1625, 1630, 1631, 1637, 1638, 1642, 1643, - 1648, 1649, 1650, 1652, 1660, 1661, 1663, 1666, 1668, 1672, - 1673, 1674, 1676, 1678, 1682, 1687, 1695, 1696, 1705, 1707, - 1712, 1713, 1714, 1718, 1719, 1720, 1724, 1725, 1726, 1730, - 1731, 1732, 1737, 1738, 1739, 1740, 1746, 1747, 1749, 1754, - 1755, 1760, 1761, 1762, 1763, 1764, 1779, 1780, 1785, 1786, - 1792, 1794, 1797, 1799, 1801, 1824, 1825, 1827, 1829, 1834, - 1835, 1837, 1842, 1847, 1848, 1854, 1853, 1857, 1861, 1863, - 1865, 1871, 1872, 1877, 1882, 1884, 1889, 1891, 1892, 1894, - 1899, 1901, 1903, 1908, 1910, 1915, 1920, 1928, 1934, 1933, - 1947, 1948, 1953, 1954, 1958, 1963, 1968, 1976, 1981, 1992, - 1993, 1998, 1999, 2005, 2006, 2010, 2011, 2012, 2015, 2014, - 2025, 2034, 2040, 2046, 2055, 2061, 2067, 2073, 2079, 2087, - 2093, 2101, 2107, 2116, 2117, 2118, 2122, 2126, 2128, 2133, - 2134, 2138, 2139, 2144, 2150, 2151, 2154, 2156, 2157, 2161, - 2162, 2163, 2164, 2198, 2200, 2201, 2203, 2208, 2213, 2218, - 2220, 2222, 2227, 2229, 2231, 2233, 2238, 2240, 2249, 2251, - 2252, 2257, 2259, 2261, 2266, 2268, 2270, 2275, 2277, 2279, - 2288, 2289, 2290, 2294, 2296, 2298, 2303, 2305, 2307, 2312, - 2314, 2316, 2331, 2333, 2334, 2336, 2341, 2342, 2347, 2349, - 2351, 2356, 2358, 2360, 2362, 2367, 2369, 2371, 2381, 2383, - 2384, 2386, 2391, 2393, 2395, 2400, 2402, 2404, 2406, 2411, - 2413, 2415, 2446, 2448, 2449, 2451, 2456, 2461, 2469, 2471, - 2473, 2478, 2480, 2485, 2487, 2501, 2502, 2504, 2509, 2511, - 2513, 2515, 2517, 2522, 2523, 2525, 2527, 2532, 2534, 2536, - 2542, 2544, 2546, 2550, 2552, 2554, 2556, 2570, 2571, 2573, - 2578, 2580, 2582, 2584, 2586, 2591, 2592, 2594, 2596, 2601, - 2603, 2605, 2611, 2612, 2614, 2623, 2626, 2628, 2631, 2633, - 2635, 2648, 2649, 2651, 2656, 2658, 2660, 2662, 2664, 2669, - 2670, 2672, 2674, 2679, 2681, 2689, 2690, 2691, 2696, 2697, - 2701, 2703, 2705, 2707, 2709, 2711, 2718, 2720, 2722, 2724, - 2726, 2728, 2730, 2732, 2734, 2736, 2741, 2743, 2745, 2750, - 2776, 2777, 2779, 2783, 2784, 2788, 2790, 2792, 2794, 2796, - 2798, 2805, 2807, 2809, 2811, 2813, 2815, 2820, 2825, 2827, - 2829, 2847, 2849, 2854, 2855 + 415, 419, 422, 424, 426, 428, 433, 436, 441, 444, + 446, 448, 453, 466, 468, 470, 472, 474, 476, 478, + 480, 482, 484, 486, 493, 494, 500, 501, 502, 503, + 507, 508, 510, 515, 516, 518, 520, 525, 526, 528, + 533, 534, 536, 541, 542, 544, 546, 548, 553, 554, + 556, 561, 562, 567, 568, 573, 574, 579, 580, 585, + 586, 591, 592, 595, 597, 602, 607, 608, 610, 616, + 617, 621, 622, 623, 624, 625, 626, 627, 628, 629, + 630, 631, 632, 638, 640, 642, 644, 649, 650, 655, + 656, 662, 663, 669, 670, 671, 672, 673, 674, 675, + 676, 677, 687, 694, 696, 706, 707, 712, 714, 720, + 722, 726, 727, 732, 737, 740, 742, 744, 754, 756, + 767, 768, 770, 774, 776, 780, 781, 786, 787, 791, + 796, 797, 801, 803, 809, 810, 814, 816, 818, 820, + 826, 827, 831, 833, 838, 840, 842, 847, 849, 854, + 856, 860, 863, 867, 870, 874, 876, 878, 880, 885, + 887, 889, 894, 896, 898, 900, 902, 907, 909, 911, + 913, 918, 930, 931, 936, 938, 943, 947, 949, 951, + 953, 955, 961, 962, 968, 969, 973, 974, 979, 981, + 987, 988, 990, 995, 1000, 1010, 1012, 1016, 1017, 1022, + 1024, 1028, 1029, 1033, 1035, 1039, 1040, 1044, 1045, 1049, + 1050, 1065, 1066, 1067, 1068, 1069, 1073, 1078, 1085, 1095, + 1100, 1105, 1113, 1118, 1123, 1128, 1133, 1141, 1163, 1168, + 1175, 1177, 1184, 1189, 1194, 1205, 1210, 1215, 1220, 1225, + 1234, 1239, 1247, 1248, 1249, 1250, 1256, 1261, 1269, 1270, + 1271, 1272, 1276, 1277, 1278, 1279, 1284, 1285, 1294, 1295, + 1300, 1301, 1306, 1308, 1310, 1312, 1314, 1317, 1316, 1328, + 1329, 1331, 1341, 1342, 1347, 1349, 1351, 1353, 1355, 1358, + 1360, 1363, 1368, 1370, 1372, 1374, 1376, 1378, 1380, 1382, + 1384, 1386, 1388, 1390, 1392, 1398, 1399, 1401, 1403, 1405, + 1410, 1411, 1417, 1418, 1420, 1422, 1427, 1429, 1431, 1433, + 1438, 1439, 1441, 1443, 1448, 1449, 1451, 1456, 1457, 1459, + 1461, 1466, 1468, 1470, 1475, 1476, 1480, 1482, 1488, 1487, + 1491, 1493, 1498, 1500, 1506, 1507, 1512, 1513, 1515, 1516, + 1525, 1526, 1528, 1530, 1535, 1537, 1543, 1544, 1546, 1549, + 1552, 1557, 1558, 1563, 1568, 1572, 1574, 1580, 1579, 1586, + 1588, 1594, 1595, 1603, 1604, 1608, 1609, 1610, 1612, 1614, + 1621, 1622, 1624, 1626, 1631, 1632, 1638, 1639, 1643, 1644, + 1649, 1650, 1651, 1653, 1661, 1662, 1664, 1667, 1669, 1673, + 1674, 1675, 1677, 1679, 1683, 1688, 1696, 1697, 1706, 1708, + 1713, 1714, 1715, 1719, 1720, 1721, 1725, 1726, 1727, 1731, + 1732, 1733, 1738, 1739, 1740, 1741, 1747, 1748, 1750, 1755, + 1756, 1761, 1762, 1763, 1764, 1765, 1780, 1781, 1786, 1787, + 1793, 1795, 1798, 1800, 1802, 1825, 1826, 1828, 1830, 1835, + 1836, 1838, 1843, 1848, 1849, 1855, 1854, 1858, 1862, 1864, + 1866, 1872, 1873, 1878, 1883, 1885, 1890, 1892, 1893, 1895, + 1900, 1902, 1904, 1909, 1911, 1916, 1921, 1929, 1935, 1934, + 1948, 1949, 1954, 1955, 1959, 1964, 1969, 1977, 1982, 1993, + 1994, 1999, 2000, 2006, 2007, 2011, 2012, 2013, 2016, 2015, + 2026, 2035, 2041, 2047, 2056, 2062, 2068, 2074, 2080, 2088, + 2094, 2102, 2108, 2117, 2118, 2119, 2123, 2127, 2129, 2134, + 2135, 2139, 2140, 2145, 2151, 2152, 2155, 2157, 2158, 2162, + 2163, 2164, 2165, 2199, 2201, 2202, 2204, 2209, 2214, 2219, + 2221, 2223, 2228, 2230, 2232, 2234, 2239, 2241, 2250, 2252, + 2253, 2258, 2260, 2262, 2267, 2269, 2271, 2276, 2278, 2280, + 2289, 2290, 2291, 2295, 2297, 2299, 2304, 2306, 2308, 2313, + 2315, 2317, 2332, 2334, 2335, 2337, 2342, 2343, 2348, 2350, + 2352, 2357, 2359, 2361, 2363, 2368, 2370, 2372, 2382, 2384, + 2385, 2387, 2392, 2394, 2396, 2401, 2403, 2405, 2407, 2412, + 2414, 2416, 2447, 2449, 2450, 2452, 2457, 2462, 2470, 2472, + 2474, 2479, 2481, 2486, 2488, 2502, 2503, 2505, 2510, 2512, + 2514, 2516, 2518, 2523, 2524, 2526, 2528, 2533, 2535, 2537, + 2543, 2545, 2547, 2551, 2553, 2555, 2557, 2571, 2572, 2574, + 2579, 2581, 2583, 2585, 2587, 2592, 2593, 2595, 2597, 2602, + 2604, 2606, 2612, 2613, 2615, 2624, 2627, 2629, 2632, 2634, + 2636, 2649, 2650, 2652, 2657, 2659, 2661, 2663, 2665, 2670, + 2671, 2673, 2675, 2680, 2682, 2690, 2691, 2692, 2697, 2698, + 2702, 2704, 2706, 2708, 2710, 2712, 2719, 2721, 2723, 2725, + 2727, 2730, 2732, 2734, 2736, 2738, 2743, 2745, 2747, 2752, + 2778, 2779, 2781, 2785, 2786, 2790, 2792, 2794, 2796, 2798, + 2800, 2807, 2809, 2811, 2813, 2815, 2817, 2822, 2827, 2829, + 2831, 2849, 2851, 2856, 2857 }; #endif @@ -5202,5 +5202,5 @@ /* Line 1806 of yacc.c */ -#line 436 "parser.yy" +#line 437 "parser.yy" { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); } break; @@ -5209,5 +5209,5 @@ /* Line 1806 of yacc.c */ -#line 444 "parser.yy" +#line 445 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; @@ -5216,5 +5216,5 @@ /* Line 1806 of yacc.c */ -#line 446 "parser.yy" +#line 447 "parser.yy" { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } break; @@ -5223,5 +5223,5 @@ /* Line 1806 of yacc.c */ -#line 448 "parser.yy" +#line 449 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); } break; @@ -5230,5 +5230,5 @@ /* Line 1806 of yacc.c */ -#line 453 "parser.yy" +#line 454 "parser.yy" { switch ( (yyvsp[(1) - (2)].op) ) { @@ -5248,5 +5248,5 @@ /* Line 1806 of yacc.c */ -#line 466 "parser.yy" +#line 467 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); } break; @@ -5255,5 +5255,5 @@ /* Line 1806 of yacc.c */ -#line 468 "parser.yy" +#line 469 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); } break; @@ -5262,5 +5262,5 @@ /* Line 1806 of yacc.c */ -#line 470 "parser.yy" +#line 471 "parser.yy" { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); } break; @@ -5269,5 +5269,5 @@ /* Line 1806 of yacc.c */ -#line 472 "parser.yy" +#line 473 "parser.yy" { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); } break; @@ -5276,5 +5276,5 @@ /* Line 1806 of yacc.c */ -#line 474 "parser.yy" +#line 475 "parser.yy" { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); } break; @@ -5283,5 +5283,5 @@ /* Line 1806 of yacc.c */ -#line 476 "parser.yy" +#line 477 "parser.yy" { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); } break; @@ -5290,5 +5290,5 @@ /* Line 1806 of yacc.c */ -#line 478 "parser.yy" +#line 479 "parser.yy" { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); } break; @@ -5297,5 +5297,5 @@ /* Line 1806 of yacc.c */ -#line 480 "parser.yy" +#line 481 "parser.yy" { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); } break; @@ -5304,5 +5304,5 @@ /* Line 1806 of yacc.c */ -#line 482 "parser.yy" +#line 483 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); } break; @@ -5311,5 +5311,5 @@ /* Line 1806 of yacc.c */ -#line 484 "parser.yy" +#line 485 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); } break; @@ -5318,5 +5318,5 @@ /* Line 1806 of yacc.c */ -#line 486 "parser.yy" +#line 487 "parser.yy" { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); } break; @@ -5325,5 +5325,5 @@ /* Line 1806 of yacc.c */ -#line 492 "parser.yy" +#line 493 "parser.yy" { (yyval.op) = OperKinds::PointTo; } break; @@ -5332,5 +5332,5 @@ /* Line 1806 of yacc.c */ -#line 493 "parser.yy" +#line 494 "parser.yy" { (yyval.op) = OperKinds::AddressOf; } break; @@ -5339,5 +5339,5 @@ /* Line 1806 of yacc.c */ -#line 499 "parser.yy" +#line 500 "parser.yy" { (yyval.op) = OperKinds::UnPlus; } break; @@ -5346,5 +5346,5 @@ /* Line 1806 of yacc.c */ -#line 500 "parser.yy" +#line 501 "parser.yy" { (yyval.op) = OperKinds::UnMinus; } break; @@ -5353,5 +5353,5 @@ /* Line 1806 of yacc.c */ -#line 501 "parser.yy" +#line 502 "parser.yy" { (yyval.op) = OperKinds::Neg; } break; @@ -5360,5 +5360,5 @@ /* Line 1806 of yacc.c */ -#line 502 "parser.yy" +#line 503 "parser.yy" { (yyval.op) = OperKinds::BitNeg; } break; @@ -5367,5 +5367,5 @@ /* Line 1806 of yacc.c */ -#line 508 "parser.yy" +#line 509 "parser.yy" { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } break; @@ -5374,5 +5374,5 @@ /* Line 1806 of yacc.c */ -#line 510 "parser.yy" +#line 511 "parser.yy" { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); } break; @@ -5381,5 +5381,5 @@ /* Line 1806 of yacc.c */ -#line 516 "parser.yy" +#line 517 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5388,5 +5388,5 @@ /* Line 1806 of yacc.c */ -#line 518 "parser.yy" +#line 519 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5395,5 +5395,5 @@ /* Line 1806 of yacc.c */ -#line 520 "parser.yy" +#line 521 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5402,5 +5402,5 @@ /* Line 1806 of yacc.c */ -#line 526 "parser.yy" +#line 527 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5409,5 +5409,5 @@ /* Line 1806 of yacc.c */ -#line 528 "parser.yy" +#line 529 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5416,5 +5416,5 @@ /* Line 1806 of yacc.c */ -#line 534 "parser.yy" +#line 535 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5423,5 +5423,5 @@ /* Line 1806 of yacc.c */ -#line 536 "parser.yy" +#line 537 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5430,5 +5430,5 @@ /* Line 1806 of yacc.c */ -#line 542 "parser.yy" +#line 543 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5437,5 +5437,5 @@ /* Line 1806 of yacc.c */ -#line 544 "parser.yy" +#line 545 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5444,5 +5444,5 @@ /* Line 1806 of yacc.c */ -#line 546 "parser.yy" +#line 547 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5451,5 +5451,5 @@ /* Line 1806 of yacc.c */ -#line 548 "parser.yy" +#line 549 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5458,5 +5458,5 @@ /* Line 1806 of yacc.c */ -#line 554 "parser.yy" +#line 555 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5465,5 +5465,5 @@ /* Line 1806 of yacc.c */ -#line 556 "parser.yy" +#line 557 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5472,5 +5472,5 @@ /* Line 1806 of yacc.c */ -#line 562 "parser.yy" +#line 563 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5479,5 +5479,5 @@ /* Line 1806 of yacc.c */ -#line 568 "parser.yy" +#line 569 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5486,5 +5486,5 @@ /* Line 1806 of yacc.c */ -#line 574 "parser.yy" +#line 575 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5493,5 +5493,5 @@ /* Line 1806 of yacc.c */ -#line 580 "parser.yy" +#line 581 "parser.yy" { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); } break; @@ -5500,5 +5500,5 @@ /* Line 1806 of yacc.c */ -#line 586 "parser.yy" +#line 587 "parser.yy" { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); } break; @@ -5507,5 +5507,5 @@ /* Line 1806 of yacc.c */ -#line 592 "parser.yy" +#line 593 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } break; @@ -5514,5 +5514,5 @@ /* Line 1806 of yacc.c */ -#line 595 "parser.yy" +#line 596 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); } break; @@ -5521,5 +5521,5 @@ /* Line 1806 of yacc.c */ -#line 597 "parser.yy" +#line 598 "parser.yy" { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); } break; @@ -5528,5 +5528,5 @@ /* Line 1806 of yacc.c */ -#line 608 "parser.yy" +#line 609 "parser.yy" { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5535,5 +5535,5 @@ /* Line 1806 of yacc.c */ -#line 610 "parser.yy" +#line 611 "parser.yy" { (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) ) ); } break; @@ -5542,5 +5542,5 @@ /* Line 1806 of yacc.c */ -#line 615 "parser.yy" +#line 616 "parser.yy" { (yyval.en) = nullptr; } break; @@ -5549,5 +5549,5 @@ /* Line 1806 of yacc.c */ -#line 620 "parser.yy" +#line 621 "parser.yy" { (yyval.op) = OperKinds::Assign; } break; @@ -5556,5 +5556,5 @@ /* Line 1806 of yacc.c */ -#line 621 "parser.yy" +#line 622 "parser.yy" { (yyval.op) = OperKinds::AtAssn; } break; @@ -5563,5 +5563,5 @@ /* Line 1806 of yacc.c */ -#line 622 "parser.yy" +#line 623 "parser.yy" { (yyval.op) = OperKinds::MulAssn; } break; @@ -5570,5 +5570,5 @@ /* Line 1806 of yacc.c */ -#line 623 "parser.yy" +#line 624 "parser.yy" { (yyval.op) = OperKinds::DivAssn; } break; @@ -5577,5 +5577,5 @@ /* Line 1806 of yacc.c */ -#line 624 "parser.yy" +#line 625 "parser.yy" { (yyval.op) = OperKinds::ModAssn; } break; @@ -5584,5 +5584,5 @@ /* Line 1806 of yacc.c */ -#line 625 "parser.yy" +#line 626 "parser.yy" { (yyval.op) = OperKinds::PlusAssn; } break; @@ -5591,5 +5591,5 @@ /* Line 1806 of yacc.c */ -#line 626 "parser.yy" +#line 627 "parser.yy" { (yyval.op) = OperKinds::MinusAssn; } break; @@ -5598,5 +5598,5 @@ /* Line 1806 of yacc.c */ -#line 627 "parser.yy" +#line 628 "parser.yy" { (yyval.op) = OperKinds::LSAssn; } break; @@ -5605,5 +5605,5 @@ /* Line 1806 of yacc.c */ -#line 628 "parser.yy" +#line 629 "parser.yy" { (yyval.op) = OperKinds::RSAssn; } break; @@ -5612,5 +5612,5 @@ /* Line 1806 of yacc.c */ -#line 629 "parser.yy" +#line 630 "parser.yy" { (yyval.op) = OperKinds::AndAssn; } break; @@ -5619,5 +5619,5 @@ /* Line 1806 of yacc.c */ -#line 630 "parser.yy" +#line 631 "parser.yy" { (yyval.op) = OperKinds::ERAssn; } break; @@ -5626,5 +5626,5 @@ /* Line 1806 of yacc.c */ -#line 631 "parser.yy" +#line 632 "parser.yy" { (yyval.op) = OperKinds::OrAssn; } break; @@ -5633,5 +5633,5 @@ /* Line 1806 of yacc.c */ -#line 638 "parser.yy" +#line 639 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple() ); } break; @@ -5640,5 +5640,5 @@ /* Line 1806 of yacc.c */ -#line 640 "parser.yy" +#line 641 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); } break; @@ -5647,5 +5647,5 @@ /* Line 1806 of yacc.c */ -#line 642 "parser.yy" +#line 643 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); } break; @@ -5654,5 +5654,5 @@ /* Line 1806 of yacc.c */ -#line 644 "parser.yy" +#line 645 "parser.yy" { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); } break; @@ -5661,5 +5661,5 @@ /* Line 1806 of yacc.c */ -#line 650 "parser.yy" +#line 651 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; @@ -5668,5 +5668,5 @@ /* Line 1806 of yacc.c */ -#line 656 "parser.yy" +#line 657 "parser.yy" { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5675,5 +5675,5 @@ /* Line 1806 of yacc.c */ -#line 661 "parser.yy" +#line 662 "parser.yy" { (yyval.en) = 0; } break; @@ -5682,5 +5682,5 @@ /* Line 1806 of yacc.c */ -#line 670 "parser.yy" +#line 671 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (1)].sn); } break; @@ -5689,5 +5689,5 @@ /* Line 1806 of yacc.c */ -#line 677 "parser.yy" +#line 678 "parser.yy" { Token fn; @@ -5700,5 +5700,5 @@ /* Line 1806 of yacc.c */ -#line 687 "parser.yy" +#line 688 "parser.yy" { (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) ); @@ -5709,5 +5709,5 @@ /* Line 1806 of yacc.c */ -#line 694 "parser.yy" +#line 695 "parser.yy" { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); } break; @@ -5716,5 +5716,5 @@ /* Line 1806 of yacc.c */ -#line 701 "parser.yy" +#line 702 "parser.yy" { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); } break; @@ -5723,5 +5723,5 @@ /* Line 1806 of yacc.c */ -#line 707 "parser.yy" +#line 708 "parser.yy" { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } } break; @@ -5730,5 +5730,5 @@ /* Line 1806 of yacc.c */ -#line 712 "parser.yy" +#line 713 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; @@ -5737,5 +5737,5 @@ /* Line 1806 of yacc.c */ -#line 714 "parser.yy" +#line 715 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -5748,5 +5748,5 @@ /* Line 1806 of yacc.c */ -#line 720 "parser.yy" +#line 721 "parser.yy" { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); } break; @@ -5755,5 +5755,5 @@ /* Line 1806 of yacc.c */ -#line 727 "parser.yy" +#line 728 "parser.yy" { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } } break; @@ -5762,5 +5762,5 @@ /* Line 1806 of yacc.c */ -#line 732 "parser.yy" +#line 733 "parser.yy" { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); } break; @@ -5769,5 +5769,5 @@ /* Line 1806 of yacc.c */ -#line 738 "parser.yy" +#line 739 "parser.yy" { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); } break; @@ -5776,5 +5776,5 @@ /* Line 1806 of yacc.c */ -#line 740 "parser.yy" +#line 741 "parser.yy" { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); } break; @@ -5783,5 +5783,5 @@ /* Line 1806 of yacc.c */ -#line 742 "parser.yy" +#line 743 "parser.yy" { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; @@ -5790,5 +5790,5 @@ /* Line 1806 of yacc.c */ -#line 744 "parser.yy" +#line 745 "parser.yy" { StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); @@ -5805,5 +5805,5 @@ /* Line 1806 of yacc.c */ -#line 754 "parser.yy" +#line 755 "parser.yy" { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; @@ -5812,5 +5812,5 @@ /* Line 1806 of yacc.c */ -#line 756 "parser.yy" +#line 757 "parser.yy" { StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) ); @@ -5822,5 +5822,5 @@ /* Line 1806 of yacc.c */ -#line 766 "parser.yy" +#line 767 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; @@ -5829,5 +5829,5 @@ /* Line 1806 of yacc.c */ -#line 768 "parser.yy" +#line 769 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -5836,5 +5836,5 @@ /* Line 1806 of yacc.c */ -#line 773 "parser.yy" +#line 774 "parser.yy" { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); } break; @@ -5843,5 +5843,5 @@ /* Line 1806 of yacc.c */ -#line 775 "parser.yy" +#line 776 "parser.yy" { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); } break; @@ -5850,5 +5850,5 @@ /* Line 1806 of yacc.c */ -#line 779 "parser.yy" +#line 780 "parser.yy" { (yyval.sn) = (yyvsp[(2) - (3)].sn); } break; @@ -5857,5 +5857,5 @@ /* Line 1806 of yacc.c */ -#line 780 "parser.yy" +#line 781 "parser.yy" { (yyval.sn) = new StatementNode( build_default() ); } break; @@ -5864,5 +5864,5 @@ /* Line 1806 of yacc.c */ -#line 786 "parser.yy" +#line 787 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); } break; @@ -5871,5 +5871,5 @@ /* Line 1806 of yacc.c */ -#line 790 "parser.yy" +#line 791 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } break; @@ -5878,5 +5878,5 @@ /* Line 1806 of yacc.c */ -#line 795 "parser.yy" +#line 796 "parser.yy" { (yyval.sn) = 0; } break; @@ -5885,5 +5885,5 @@ /* Line 1806 of yacc.c */ -#line 801 "parser.yy" +#line 802 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); } break; @@ -5892,5 +5892,5 @@ /* Line 1806 of yacc.c */ -#line 803 "parser.yy" +#line 804 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); } break; @@ -5899,5 +5899,5 @@ /* Line 1806 of yacc.c */ -#line 808 "parser.yy" +#line 809 "parser.yy" { (yyval.sn) = 0; } break; @@ -5906,5 +5906,5 @@ /* Line 1806 of yacc.c */ -#line 814 "parser.yy" +#line 815 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); } break; @@ -5913,5 +5913,5 @@ /* Line 1806 of yacc.c */ -#line 816 "parser.yy" +#line 817 "parser.yy" { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); } break; @@ -5920,5 +5920,5 @@ /* Line 1806 of yacc.c */ -#line 818 "parser.yy" +#line 819 "parser.yy" { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); } break; @@ -5927,5 +5927,5 @@ /* Line 1806 of yacc.c */ -#line 820 "parser.yy" +#line 821 "parser.yy" { (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) ) ) ) ) ) ); } break; @@ -5934,5 +5934,5 @@ /* Line 1806 of yacc.c */ -#line 825 "parser.yy" +#line 826 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } break; @@ -5941,5 +5941,5 @@ /* Line 1806 of yacc.c */ -#line 831 "parser.yy" +#line 832 "parser.yy" { (yyval.sn) = 0; } break; @@ -5948,5 +5948,5 @@ /* Line 1806 of yacc.c */ -#line 833 "parser.yy" +#line 834 "parser.yy" { (yyval.sn) = 0; } break; @@ -5955,5 +5955,5 @@ /* Line 1806 of yacc.c */ -#line 838 "parser.yy" +#line 839 "parser.yy" { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); } break; @@ -5962,5 +5962,5 @@ /* Line 1806 of yacc.c */ -#line 840 "parser.yy" +#line 841 "parser.yy" { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); } break; @@ -5969,5 +5969,5 @@ /* Line 1806 of yacc.c */ -#line 842 "parser.yy" +#line 843 "parser.yy" { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); } break; @@ -5976,5 +5976,5 @@ /* Line 1806 of yacc.c */ -#line 847 "parser.yy" +#line 848 "parser.yy" { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); } break; @@ -5983,5 +5983,5 @@ /* Line 1806 of yacc.c */ -#line 849 "parser.yy" +#line 850 "parser.yy" { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); } break; @@ -5990,5 +5990,5 @@ /* Line 1806 of yacc.c */ -#line 854 "parser.yy" +#line 855 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); } break; @@ -5997,5 +5997,5 @@ /* Line 1806 of yacc.c */ -#line 858 "parser.yy" +#line 859 "parser.yy" { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); } break; @@ -6004,5 +6004,5 @@ /* Line 1806 of yacc.c */ -#line 861 "parser.yy" +#line 862 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); } break; @@ -6011,5 +6011,5 @@ /* Line 1806 of yacc.c */ -#line 865 "parser.yy" +#line 866 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); } break; @@ -6018,5 +6018,5 @@ /* Line 1806 of yacc.c */ -#line 868 "parser.yy" +#line 869 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); } break; @@ -6025,5 +6025,5 @@ /* Line 1806 of yacc.c */ -#line 872 "parser.yy" +#line 873 "parser.yy" { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); } break; @@ -6032,5 +6032,5 @@ /* Line 1806 of yacc.c */ -#line 874 "parser.yy" +#line 875 "parser.yy" { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); } break; @@ -6039,5 +6039,5 @@ /* Line 1806 of yacc.c */ -#line 876 "parser.yy" +#line 877 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } break; @@ -6046,5 +6046,5 @@ /* Line 1806 of yacc.c */ -#line 878 "parser.yy" +#line 879 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); } break; @@ -6053,5 +6053,5 @@ /* Line 1806 of yacc.c */ -#line 880 "parser.yy" +#line 881 "parser.yy" { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); } break; @@ -6060,5 +6060,5 @@ /* Line 1806 of yacc.c */ -#line 885 "parser.yy" +#line 886 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); } break; @@ -6067,5 +6067,5 @@ /* Line 1806 of yacc.c */ -#line 887 "parser.yy" +#line 888 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); } break; @@ -6074,5 +6074,5 @@ /* Line 1806 of yacc.c */ -#line 889 "parser.yy" +#line 890 "parser.yy" { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); } break; @@ -6081,5 +6081,5 @@ /* Line 1806 of yacc.c */ -#line 896 "parser.yy" +#line 897 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } break; @@ -6088,5 +6088,5 @@ /* Line 1806 of yacc.c */ -#line 898 "parser.yy" +#line 899 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } break; @@ -6095,5 +6095,5 @@ /* Line 1806 of yacc.c */ -#line 900 "parser.yy" +#line 901 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); } break; @@ -6102,5 +6102,5 @@ /* Line 1806 of yacc.c */ -#line 902 "parser.yy" +#line 903 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); } break; @@ -6109,5 +6109,5 @@ /* Line 1806 of yacc.c */ -#line 907 "parser.yy" +#line 908 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } break; @@ -6116,5 +6116,5 @@ /* Line 1806 of yacc.c */ -#line 909 "parser.yy" +#line 910 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } break; @@ -6123,5 +6123,5 @@ /* Line 1806 of yacc.c */ -#line 911 "parser.yy" +#line 912 "parser.yy" { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); } break; @@ -6130,5 +6130,5 @@ /* Line 1806 of yacc.c */ -#line 913 "parser.yy" +#line 914 "parser.yy" { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); } break; @@ -6137,5 +6137,5 @@ /* Line 1806 of yacc.c */ -#line 918 "parser.yy" +#line 919 "parser.yy" { (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) ); @@ -6146,5 +6146,5 @@ /* Line 1806 of yacc.c */ -#line 931 "parser.yy" +#line 932 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6156,5 +6156,5 @@ /* Line 1806 of yacc.c */ -#line 936 "parser.yy" +#line 937 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; @@ -6163,5 +6163,5 @@ /* Line 1806 of yacc.c */ -#line 938 "parser.yy" +#line 939 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6173,5 +6173,5 @@ /* Line 1806 of yacc.c */ -#line 947 "parser.yy" +#line 948 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); } break; @@ -6180,5 +6180,5 @@ /* Line 1806 of yacc.c */ -#line 949 "parser.yy" +#line 950 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); } break; @@ -6187,5 +6187,5 @@ /* Line 1806 of yacc.c */ -#line 951 "parser.yy" +#line 952 "parser.yy" { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); } break; @@ -6194,5 +6194,5 @@ /* Line 1806 of yacc.c */ -#line 953 "parser.yy" +#line 954 "parser.yy" { (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) ) ); } break; @@ -6201,5 +6201,5 @@ /* Line 1806 of yacc.c */ -#line 955 "parser.yy" +#line 956 "parser.yy" { (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) ) ); } break; @@ -6208,5 +6208,5 @@ /* Line 1806 of yacc.c */ -#line 960 "parser.yy" +#line 961 "parser.yy" { (yyval.flag) = false; } break; @@ -6215,5 +6215,5 @@ /* Line 1806 of yacc.c */ -#line 962 "parser.yy" +#line 963 "parser.yy" { (yyval.flag) = true; } break; @@ -6222,5 +6222,5 @@ /* Line 1806 of yacc.c */ -#line 967 "parser.yy" +#line 968 "parser.yy" { (yyval.en) = 0; } break; @@ -6229,5 +6229,5 @@ /* Line 1806 of yacc.c */ -#line 974 "parser.yy" +#line 975 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); } break; @@ -6236,5 +6236,5 @@ /* Line 1806 of yacc.c */ -#line 979 "parser.yy" +#line 980 "parser.yy" { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); } break; @@ -6243,5 +6243,5 @@ /* Line 1806 of yacc.c */ -#line 981 "parser.yy" +#line 982 "parser.yy" { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); } break; @@ -6250,5 +6250,5 @@ /* Line 1806 of yacc.c */ -#line 986 "parser.yy" +#line 987 "parser.yy" { (yyval.en) = 0; } break; @@ -6257,5 +6257,5 @@ /* Line 1806 of yacc.c */ -#line 988 "parser.yy" +#line 989 "parser.yy" { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); } break; @@ -6264,5 +6264,5 @@ /* Line 1806 of yacc.c */ -#line 990 "parser.yy" +#line 991 "parser.yy" { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); } break; @@ -6271,5 +6271,5 @@ /* Line 1806 of yacc.c */ -#line 995 "parser.yy" +#line 996 "parser.yy" { (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) ); @@ -6281,5 +6281,5 @@ /* Line 1806 of yacc.c */ -#line 1000 "parser.yy" +#line 1001 "parser.yy" { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) ); @@ -6291,5 +6291,5 @@ /* Line 1806 of yacc.c */ -#line 1010 "parser.yy" +#line 1011 "parser.yy" { (yyval.decl) = 0; } break; @@ -6298,5 +6298,5 @@ /* Line 1806 of yacc.c */ -#line 1017 "parser.yy" +#line 1018 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; @@ -6305,5 +6305,5 @@ /* Line 1806 of yacc.c */ -#line 1022 "parser.yy" +#line 1023 "parser.yy" { (yyval.decl) = 0; } break; @@ -6312,16 +6312,9 @@ /* Line 1806 of yacc.c */ -#line 1029 "parser.yy" +#line 1030 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; case 247: - -/* Line 1806 of yacc.c */ -#line 1043 "parser.yy" - {} - break; - - case 248: /* Line 1806 of yacc.c */ @@ -6330,8 +6323,15 @@ break; + case 248: + +/* Line 1806 of yacc.c */ +#line 1045 "parser.yy" + {} + break; + case 256: /* Line 1806 of yacc.c */ -#line 1073 "parser.yy" +#line 1074 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6343,5 +6343,5 @@ /* Line 1806 of yacc.c */ -#line 1080 "parser.yy" +#line 1081 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6353,5 +6353,5 @@ /* Line 1806 of yacc.c */ -#line 1085 "parser.yy" +#line 1086 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID ); @@ -6363,5 +6363,5 @@ /* Line 1806 of yacc.c */ -#line 1095 "parser.yy" +#line 1096 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6373,5 +6373,5 @@ /* Line 1806 of yacc.c */ -#line 1100 "parser.yy" +#line 1101 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) ); @@ -6383,5 +6383,5 @@ /* Line 1806 of yacc.c */ -#line 1105 "parser.yy" +#line 1106 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) ); @@ -6393,5 +6393,5 @@ /* Line 1806 of yacc.c */ -#line 1113 "parser.yy" +#line 1114 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6403,5 +6403,5 @@ /* Line 1806 of yacc.c */ -#line 1118 "parser.yy" +#line 1119 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6413,5 +6413,5 @@ /* Line 1806 of yacc.c */ -#line 1123 "parser.yy" +#line 1124 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6423,5 +6423,5 @@ /* Line 1806 of yacc.c */ -#line 1128 "parser.yy" +#line 1129 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6433,5 +6433,5 @@ /* Line 1806 of yacc.c */ -#line 1133 "parser.yy" +#line 1134 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -6443,5 +6443,5 @@ /* Line 1806 of yacc.c */ -#line 1141 "parser.yy" +#line 1142 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true ); @@ -6452,5 +6452,5 @@ /* Line 1806 of yacc.c */ -#line 1164 "parser.yy" +#line 1165 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6461,5 +6461,5 @@ /* Line 1806 of yacc.c */ -#line 1168 "parser.yy" +#line 1169 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true ); @@ -6470,5 +6470,5 @@ /* Line 1806 of yacc.c */ -#line 1175 "parser.yy" +#line 1176 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; @@ -6477,5 +6477,5 @@ /* Line 1806 of yacc.c */ -#line 1179 "parser.yy" +#line 1180 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); } break; @@ -6484,5 +6484,5 @@ /* Line 1806 of yacc.c */ -#line 1184 "parser.yy" +#line 1185 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6494,5 +6494,5 @@ /* Line 1806 of yacc.c */ -#line 1189 "parser.yy" +#line 1190 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6504,5 +6504,5 @@ /* Line 1806 of yacc.c */ -#line 1194 "parser.yy" +#line 1195 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD ); @@ -6514,5 +6514,5 @@ /* Line 1806 of yacc.c */ -#line 1205 "parser.yy" +#line 1206 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6524,5 +6524,5 @@ /* Line 1806 of yacc.c */ -#line 1210 "parser.yy" +#line 1211 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6534,5 +6534,5 @@ /* Line 1806 of yacc.c */ -#line 1215 "parser.yy" +#line 1216 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6544,5 +6544,5 @@ /* Line 1806 of yacc.c */ -#line 1220 "parser.yy" +#line 1221 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6554,5 +6554,5 @@ /* Line 1806 of yacc.c */ -#line 1225 "parser.yy" +#line 1226 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::TD ); @@ -6564,5 +6564,5 @@ /* Line 1806 of yacc.c */ -#line 1234 "parser.yy" +#line 1235 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD ); @@ -6574,5 +6574,5 @@ /* Line 1806 of yacc.c */ -#line 1239 "parser.yy" +#line 1240 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD ); @@ -6584,5 +6584,5 @@ /* Line 1806 of yacc.c */ -#line 1256 "parser.yy" +#line 1257 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6594,5 +6594,5 @@ /* Line 1806 of yacc.c */ -#line 1261 "parser.yy" +#line 1262 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -6604,5 +6604,5 @@ /* Line 1806 of yacc.c */ -#line 1283 "parser.yy" +#line 1284 "parser.yy" { (yyval.decl) = 0; } break; @@ -6611,5 +6611,5 @@ /* Line 1806 of yacc.c */ -#line 1295 "parser.yy" +#line 1296 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6618,5 +6618,5 @@ /* Line 1806 of yacc.c */ -#line 1306 "parser.yy" +#line 1307 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); } break; @@ -6625,5 +6625,5 @@ /* Line 1806 of yacc.c */ -#line 1308 "parser.yy" +#line 1309 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); } break; @@ -6632,5 +6632,5 @@ /* Line 1806 of yacc.c */ -#line 1310 "parser.yy" +#line 1311 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); } break; @@ -6639,5 +6639,5 @@ /* Line 1806 of yacc.c */ -#line 1312 "parser.yy" +#line 1313 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); } break; @@ -6646,5 +6646,5 @@ /* Line 1806 of yacc.c */ -#line 1314 "parser.yy" +#line 1315 "parser.yy" { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); } break; @@ -6653,5 +6653,5 @@ /* Line 1806 of yacc.c */ -#line 1316 "parser.yy" +#line 1317 "parser.yy" { typedefTable.enterScope(); @@ -6662,5 +6662,5 @@ /* Line 1806 of yacc.c */ -#line 1320 "parser.yy" +#line 1321 "parser.yy" { typedefTable.leaveScope(); @@ -6672,5 +6672,5 @@ /* Line 1806 of yacc.c */ -#line 1329 "parser.yy" +#line 1330 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6679,5 +6679,5 @@ /* Line 1806 of yacc.c */ -#line 1331 "parser.yy" +#line 1332 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -6686,5 +6686,5 @@ /* Line 1806 of yacc.c */ -#line 1342 "parser.yy" +#line 1343 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6693,5 +6693,5 @@ /* Line 1806 of yacc.c */ -#line 1347 "parser.yy" +#line 1348 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); } break; @@ -6700,5 +6700,5 @@ /* Line 1806 of yacc.c */ -#line 1349 "parser.yy" +#line 1350 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); } break; @@ -6707,5 +6707,5 @@ /* Line 1806 of yacc.c */ -#line 1351 "parser.yy" +#line 1352 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); } break; @@ -6714,5 +6714,5 @@ /* Line 1806 of yacc.c */ -#line 1353 "parser.yy" +#line 1354 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); } break; @@ -6721,5 +6721,5 @@ /* Line 1806 of yacc.c */ -#line 1356 "parser.yy" +#line 1357 "parser.yy" { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; } break; @@ -6728,5 +6728,5 @@ /* Line 1806 of yacc.c */ -#line 1358 "parser.yy" +#line 1359 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } break; @@ -6735,5 +6735,5 @@ /* Line 1806 of yacc.c */ -#line 1361 "parser.yy" +#line 1362 "parser.yy" { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; } break; @@ -6742,5 +6742,5 @@ /* Line 1806 of yacc.c */ -#line 1363 "parser.yy" +#line 1364 "parser.yy" { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); } break; @@ -6749,5 +6749,5 @@ /* Line 1806 of yacc.c */ -#line 1368 "parser.yy" +#line 1369 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); } break; @@ -6756,5 +6756,5 @@ /* Line 1806 of yacc.c */ -#line 1370 "parser.yy" +#line 1371 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); } break; @@ -6763,5 +6763,5 @@ /* Line 1806 of yacc.c */ -#line 1372 "parser.yy" +#line 1373 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); } break; @@ -6770,5 +6770,5 @@ /* Line 1806 of yacc.c */ -#line 1374 "parser.yy" +#line 1375 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); } break; @@ -6777,5 +6777,5 @@ /* Line 1806 of yacc.c */ -#line 1376 "parser.yy" +#line 1377 "parser.yy" { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); } break; @@ -6784,5 +6784,5 @@ /* Line 1806 of yacc.c */ -#line 1378 "parser.yy" +#line 1379 "parser.yy" { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); } break; @@ -6791,5 +6791,5 @@ /* Line 1806 of yacc.c */ -#line 1380 "parser.yy" +#line 1381 "parser.yy" { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } break; @@ -6798,5 +6798,5 @@ /* Line 1806 of yacc.c */ -#line 1382 "parser.yy" +#line 1383 "parser.yy" { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } break; @@ -6805,5 +6805,5 @@ /* Line 1806 of yacc.c */ -#line 1384 "parser.yy" +#line 1385 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); } break; @@ -6812,5 +6812,5 @@ /* Line 1806 of yacc.c */ -#line 1386 "parser.yy" +#line 1387 "parser.yy" { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); } break; @@ -6819,5 +6819,5 @@ /* Line 1806 of yacc.c */ -#line 1388 "parser.yy" +#line 1389 "parser.yy" { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); } break; @@ -6826,5 +6826,5 @@ /* Line 1806 of yacc.c */ -#line 1390 "parser.yy" +#line 1391 "parser.yy" { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } break; @@ -6833,5 +6833,5 @@ /* Line 1806 of yacc.c */ -#line 1392 "parser.yy" +#line 1393 "parser.yy" { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } break; @@ -6840,5 +6840,5 @@ /* Line 1806 of yacc.c */ -#line 1399 "parser.yy" +#line 1400 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -6847,5 +6847,5 @@ /* Line 1806 of yacc.c */ -#line 1401 "parser.yy" +#line 1402 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6854,5 +6854,5 @@ /* Line 1806 of yacc.c */ -#line 1403 "parser.yy" +#line 1404 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -6861,5 +6861,5 @@ /* Line 1806 of yacc.c */ -#line 1405 "parser.yy" +#line 1406 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); } break; @@ -6868,5 +6868,5 @@ /* Line 1806 of yacc.c */ -#line 1411 "parser.yy" +#line 1412 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -6875,5 +6875,5 @@ /* Line 1806 of yacc.c */ -#line 1418 "parser.yy" +#line 1419 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -6882,5 +6882,5 @@ /* Line 1806 of yacc.c */ -#line 1420 "parser.yy" +#line 1421 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6889,5 +6889,5 @@ /* Line 1806 of yacc.c */ -#line 1422 "parser.yy" +#line 1423 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); } break; @@ -6896,5 +6896,5 @@ /* Line 1806 of yacc.c */ -#line 1427 "parser.yy" +#line 1428 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (4)].decl); } break; @@ -6903,5 +6903,5 @@ /* Line 1806 of yacc.c */ -#line 1429 "parser.yy" +#line 1430 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); } break; @@ -6910,5 +6910,5 @@ /* Line 1806 of yacc.c */ -#line 1431 "parser.yy" +#line 1432 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); } break; @@ -6917,5 +6917,5 @@ /* Line 1806 of yacc.c */ -#line 1433 "parser.yy" +#line 1434 "parser.yy" { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; @@ -6924,5 +6924,5 @@ /* Line 1806 of yacc.c */ -#line 1439 "parser.yy" +#line 1440 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -6931,5 +6931,5 @@ /* Line 1806 of yacc.c */ -#line 1441 "parser.yy" +#line 1442 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6938,5 +6938,5 @@ /* Line 1806 of yacc.c */ -#line 1443 "parser.yy" +#line 1444 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -6945,5 +6945,5 @@ /* Line 1806 of yacc.c */ -#line 1449 "parser.yy" +#line 1450 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -6952,5 +6952,5 @@ /* Line 1806 of yacc.c */ -#line 1451 "parser.yy" +#line 1452 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6959,5 +6959,5 @@ /* Line 1806 of yacc.c */ -#line 1457 "parser.yy" +#line 1458 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -6966,5 +6966,5 @@ /* Line 1806 of yacc.c */ -#line 1459 "parser.yy" +#line 1460 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -6973,5 +6973,5 @@ /* Line 1806 of yacc.c */ -#line 1461 "parser.yy" +#line 1462 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -6980,5 +6980,5 @@ /* Line 1806 of yacc.c */ -#line 1466 "parser.yy" +#line 1467 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); } break; @@ -6987,5 +6987,5 @@ /* Line 1806 of yacc.c */ -#line 1468 "parser.yy" +#line 1469 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -6994,5 +6994,5 @@ /* Line 1806 of yacc.c */ -#line 1470 "parser.yy" +#line 1471 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -7001,5 +7001,5 @@ /* Line 1806 of yacc.c */ -#line 1480 "parser.yy" +#line 1481 "parser.yy" { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); } break; @@ -7008,5 +7008,5 @@ /* Line 1806 of yacc.c */ -#line 1482 "parser.yy" +#line 1483 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); @@ -7018,5 +7018,5 @@ /* Line 1806 of yacc.c */ -#line 1487 "parser.yy" +#line 1488 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } break; @@ -7025,5 +7025,5 @@ /* Line 1806 of yacc.c */ -#line 1489 "parser.yy" +#line 1490 "parser.yy" { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); } break; @@ -7032,5 +7032,5 @@ /* Line 1806 of yacc.c */ -#line 1491 "parser.yy" +#line 1492 "parser.yy" { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); } break; @@ -7039,5 +7039,5 @@ /* Line 1806 of yacc.c */ -#line 1493 "parser.yy" +#line 1494 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; @@ -7046,5 +7046,5 @@ /* Line 1806 of yacc.c */ -#line 1498 "parser.yy" +#line 1499 "parser.yy" { (yyval.aggKey) = DeclarationNode::Struct; } break; @@ -7053,5 +7053,5 @@ /* Line 1806 of yacc.c */ -#line 1500 "parser.yy" +#line 1501 "parser.yy" { (yyval.aggKey) = DeclarationNode::Union; } break; @@ -7060,5 +7060,5 @@ /* Line 1806 of yacc.c */ -#line 1505 "parser.yy" +#line 1506 "parser.yy" { (yyval.decl) = 0; } break; @@ -7067,5 +7067,5 @@ /* Line 1806 of yacc.c */ -#line 1507 "parser.yy" +#line 1508 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } break; @@ -7074,5 +7074,5 @@ /* Line 1806 of yacc.c */ -#line 1513 "parser.yy" +#line 1514 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); } break; @@ -7081,5 +7081,5 @@ /* Line 1806 of yacc.c */ -#line 1516 "parser.yy" +#line 1517 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -7092,5 +7092,5 @@ /* Line 1806 of yacc.c */ -#line 1526 "parser.yy" +#line 1527 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); } break; @@ -7099,5 +7099,5 @@ /* Line 1806 of yacc.c */ -#line 1528 "parser.yy" +#line 1529 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); } break; @@ -7106,5 +7106,5 @@ /* Line 1806 of yacc.c */ -#line 1530 "parser.yy" +#line 1531 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); } break; @@ -7113,5 +7113,5 @@ /* Line 1806 of yacc.c */ -#line 1535 "parser.yy" +#line 1536 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; @@ -7120,5 +7120,5 @@ /* Line 1806 of yacc.c */ -#line 1537 "parser.yy" +#line 1538 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); } break; @@ -7127,5 +7127,5 @@ /* Line 1806 of yacc.c */ -#line 1542 "parser.yy" +#line 1543 "parser.yy" { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ } break; @@ -7134,5 +7134,5 @@ /* Line 1806 of yacc.c */ -#line 1544 "parser.yy" +#line 1545 "parser.yy" { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); } break; @@ -7141,5 +7141,5 @@ /* Line 1806 of yacc.c */ -#line 1547 "parser.yy" +#line 1548 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; @@ -7148,5 +7148,5 @@ /* Line 1806 of yacc.c */ -#line 1550 "parser.yy" +#line 1551 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); } break; @@ -7155,5 +7155,5 @@ /* Line 1806 of yacc.c */ -#line 1556 "parser.yy" +#line 1557 "parser.yy" { (yyval.en) = 0; } break; @@ -7162,5 +7162,5 @@ /* Line 1806 of yacc.c */ -#line 1558 "parser.yy" +#line 1559 "parser.yy" { (yyval.en) = (yyvsp[(1) - (1)].en); } break; @@ -7169,5 +7169,5 @@ /* Line 1806 of yacc.c */ -#line 1563 "parser.yy" +#line 1564 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -7176,5 +7176,5 @@ /* Line 1806 of yacc.c */ -#line 1572 "parser.yy" +#line 1573 "parser.yy" { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); } break; @@ -7183,5 +7183,5 @@ /* Line 1806 of yacc.c */ -#line 1574 "parser.yy" +#line 1575 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); @@ -7193,5 +7193,5 @@ /* Line 1806 of yacc.c */ -#line 1579 "parser.yy" +#line 1580 "parser.yy" { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); } break; @@ -7200,5 +7200,5 @@ /* Line 1806 of yacc.c */ -#line 1581 "parser.yy" +#line 1582 "parser.yy" { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); } break; @@ -7207,5 +7207,5 @@ /* Line 1806 of yacc.c */ -#line 1586 "parser.yy" +#line 1587 "parser.yy" { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); } break; @@ -7214,5 +7214,5 @@ /* Line 1806 of yacc.c */ -#line 1588 "parser.yy" +#line 1589 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); } break; @@ -7221,5 +7221,5 @@ /* Line 1806 of yacc.c */ -#line 1593 "parser.yy" +#line 1594 "parser.yy" { (yyval.en) = 0; } break; @@ -7228,5 +7228,5 @@ /* Line 1806 of yacc.c */ -#line 1595 "parser.yy" +#line 1596 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -7235,5 +7235,5 @@ /* Line 1806 of yacc.c */ -#line 1602 "parser.yy" +#line 1603 "parser.yy" { (yyval.decl) = 0; } break; @@ -7242,5 +7242,5 @@ /* Line 1806 of yacc.c */ -#line 1610 "parser.yy" +#line 1611 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; @@ -7249,5 +7249,5 @@ /* Line 1806 of yacc.c */ -#line 1612 "parser.yy" +#line 1613 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; @@ -7256,5 +7256,5 @@ /* Line 1806 of yacc.c */ -#line 1614 "parser.yy" +#line 1615 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; @@ -7263,5 +7263,5 @@ /* Line 1806 of yacc.c */ -#line 1622 "parser.yy" +#line 1623 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; @@ -7270,5 +7270,5 @@ /* Line 1806 of yacc.c */ -#line 1624 "parser.yy" +#line 1625 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; @@ -7277,5 +7277,5 @@ /* Line 1806 of yacc.c */ -#line 1626 "parser.yy" +#line 1627 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); } break; @@ -7284,5 +7284,5 @@ /* Line 1806 of yacc.c */ -#line 1632 "parser.yy" +#line 1633 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; @@ -7291,5 +7291,5 @@ /* Line 1806 of yacc.c */ -#line 1637 "parser.yy" +#line 1638 "parser.yy" { (yyval.decl) = 0; } break; @@ -7298,5 +7298,5 @@ /* Line 1806 of yacc.c */ -#line 1644 "parser.yy" +#line 1645 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); } break; @@ -7305,5 +7305,5 @@ /* Line 1806 of yacc.c */ -#line 1651 "parser.yy" +#line 1652 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; @@ -7312,5 +7312,5 @@ /* Line 1806 of yacc.c */ -#line 1653 "parser.yy" +#line 1654 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); } break; @@ -7319,5 +7319,5 @@ /* Line 1806 of yacc.c */ -#line 1662 "parser.yy" +#line 1663 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; @@ -7326,5 +7326,5 @@ /* Line 1806 of yacc.c */ -#line 1665 "parser.yy" +#line 1666 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); } break; @@ -7333,5 +7333,5 @@ /* Line 1806 of yacc.c */ -#line 1667 "parser.yy" +#line 1668 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); } break; @@ -7340,5 +7340,5 @@ /* Line 1806 of yacc.c */ -#line 1677 "parser.yy" +#line 1678 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -7347,5 +7347,5 @@ /* Line 1806 of yacc.c */ -#line 1683 "parser.yy" +#line 1684 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7357,5 +7357,5 @@ /* Line 1806 of yacc.c */ -#line 1688 "parser.yy" +#line 1689 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7367,5 +7367,5 @@ /* Line 1806 of yacc.c */ -#line 1697 "parser.yy" +#line 1698 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; @@ -7374,5 +7374,5 @@ /* Line 1806 of yacc.c */ -#line 1706 "parser.yy" +#line 1707 "parser.yy" { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); } break; @@ -7381,5 +7381,5 @@ /* Line 1806 of yacc.c */ -#line 1708 "parser.yy" +#line 1709 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); } break; @@ -7388,5 +7388,5 @@ /* Line 1806 of yacc.c */ -#line 1733 "parser.yy" +#line 1734 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; @@ -7395,5 +7395,5 @@ /* Line 1806 of yacc.c */ -#line 1741 "parser.yy" +#line 1742 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); } break; @@ -7402,5 +7402,5 @@ /* Line 1806 of yacc.c */ -#line 1746 "parser.yy" +#line 1747 "parser.yy" { (yyval.in) = 0; } break; @@ -7409,5 +7409,5 @@ /* Line 1806 of yacc.c */ -#line 1748 "parser.yy" +#line 1749 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in); } break; @@ -7416,5 +7416,5 @@ /* Line 1806 of yacc.c */ -#line 1750 "parser.yy" +#line 1751 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); } break; @@ -7423,5 +7423,5 @@ /* Line 1806 of yacc.c */ -#line 1754 "parser.yy" +#line 1755 "parser.yy" { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); } break; @@ -7430,5 +7430,5 @@ /* Line 1806 of yacc.c */ -#line 1755 "parser.yy" +#line 1756 "parser.yy" { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); } break; @@ -7437,5 +7437,5 @@ /* Line 1806 of yacc.c */ -#line 1760 "parser.yy" +#line 1761 "parser.yy" { (yyval.in) = 0; } break; @@ -7444,5 +7444,5 @@ /* Line 1806 of yacc.c */ -#line 1762 "parser.yy" +#line 1763 "parser.yy" { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); } break; @@ -7451,5 +7451,5 @@ /* Line 1806 of yacc.c */ -#line 1763 "parser.yy" +#line 1764 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); } break; @@ -7458,5 +7458,5 @@ /* Line 1806 of yacc.c */ -#line 1765 "parser.yy" +#line 1766 "parser.yy" { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); } break; @@ -7465,5 +7465,5 @@ /* Line 1806 of yacc.c */ -#line 1781 "parser.yy" +#line 1782 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); } break; @@ -7472,5 +7472,5 @@ /* Line 1806 of yacc.c */ -#line 1787 "parser.yy" +#line 1788 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); } break; @@ -7479,5 +7479,5 @@ /* Line 1806 of yacc.c */ -#line 1793 "parser.yy" +#line 1794 "parser.yy" { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); } break; @@ -7486,5 +7486,5 @@ /* Line 1806 of yacc.c */ -#line 1796 "parser.yy" +#line 1797 "parser.yy" { (yyval.en) = (yyvsp[(3) - (5)].en); } break; @@ -7493,5 +7493,5 @@ /* Line 1806 of yacc.c */ -#line 1798 "parser.yy" +#line 1799 "parser.yy" { (yyval.en) = (yyvsp[(3) - (5)].en); } break; @@ -7500,5 +7500,5 @@ /* Line 1806 of yacc.c */ -#line 1800 "parser.yy" +#line 1801 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); } break; @@ -7507,5 +7507,5 @@ /* Line 1806 of yacc.c */ -#line 1802 "parser.yy" +#line 1803 "parser.yy" { (yyval.en) = (yyvsp[(4) - (6)].en); } break; @@ -7514,5 +7514,5 @@ /* Line 1806 of yacc.c */ -#line 1826 "parser.yy" +#line 1827 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -7521,5 +7521,5 @@ /* Line 1806 of yacc.c */ -#line 1828 "parser.yy" +#line 1829 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -7528,5 +7528,5 @@ /* Line 1806 of yacc.c */ -#line 1830 "parser.yy" +#line 1831 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); } break; @@ -7535,5 +7535,5 @@ /* Line 1806 of yacc.c */ -#line 1836 "parser.yy" +#line 1837 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -7542,5 +7542,5 @@ /* Line 1806 of yacc.c */ -#line 1838 "parser.yy" +#line 1839 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -7549,5 +7549,5 @@ /* Line 1806 of yacc.c */ -#line 1843 "parser.yy" +#line 1844 "parser.yy" { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); } break; @@ -7556,5 +7556,5 @@ /* Line 1806 of yacc.c */ -#line 1849 "parser.yy" +#line 1850 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); } break; @@ -7563,5 +7563,5 @@ /* Line 1806 of yacc.c */ -#line 1854 "parser.yy" +#line 1855 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); } break; @@ -7570,5 +7570,5 @@ /* Line 1806 of yacc.c */ -#line 1856 "parser.yy" +#line 1857 "parser.yy" { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); } break; @@ -7577,5 +7577,5 @@ /* Line 1806 of yacc.c */ -#line 1862 "parser.yy" +#line 1863 "parser.yy" { (yyval.tclass) = DeclarationNode::Otype; } break; @@ -7584,5 +7584,5 @@ /* Line 1806 of yacc.c */ -#line 1864 "parser.yy" +#line 1865 "parser.yy" { (yyval.tclass) = DeclarationNode::Ftype; } break; @@ -7591,5 +7591,5 @@ /* Line 1806 of yacc.c */ -#line 1866 "parser.yy" +#line 1867 "parser.yy" { (yyval.tclass) = DeclarationNode::Dtype; } break; @@ -7598,5 +7598,5 @@ /* Line 1806 of yacc.c */ -#line 1871 "parser.yy" +#line 1872 "parser.yy" { (yyval.decl) = 0; } break; @@ -7605,5 +7605,5 @@ /* Line 1806 of yacc.c */ -#line 1873 "parser.yy" +#line 1874 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); } break; @@ -7612,5 +7612,5 @@ /* Line 1806 of yacc.c */ -#line 1878 "parser.yy" +#line 1879 "parser.yy" { typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) ); @@ -7622,5 +7622,5 @@ /* Line 1806 of yacc.c */ -#line 1883 "parser.yy" +#line 1884 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (5)].decl); } break; @@ -7629,5 +7629,5 @@ /* Line 1806 of yacc.c */ -#line 1885 "parser.yy" +#line 1886 "parser.yy" { (yyval.decl) = 0; } break; @@ -7636,5 +7636,5 @@ /* Line 1806 of yacc.c */ -#line 1890 "parser.yy" +#line 1891 "parser.yy" { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); } break; @@ -7643,5 +7643,5 @@ /* Line 1806 of yacc.c */ -#line 1893 "parser.yy" +#line 1894 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); } break; @@ -7650,5 +7650,5 @@ /* Line 1806 of yacc.c */ -#line 1895 "parser.yy" +#line 1896 "parser.yy" { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); } break; @@ -7657,5 +7657,5 @@ /* Line 1806 of yacc.c */ -#line 1900 "parser.yy" +#line 1901 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl); } break; @@ -7664,5 +7664,5 @@ /* Line 1806 of yacc.c */ -#line 1902 "parser.yy" +#line 1903 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); } break; @@ -7671,5 +7671,5 @@ /* Line 1806 of yacc.c */ -#line 1904 "parser.yy" +#line 1905 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -7678,5 +7678,5 @@ /* Line 1806 of yacc.c */ -#line 1909 "parser.yy" +#line 1910 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); } break; @@ -7685,5 +7685,5 @@ /* Line 1806 of yacc.c */ -#line 1911 "parser.yy" +#line 1912 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); } break; @@ -7692,5 +7692,5 @@ /* Line 1806 of yacc.c */ -#line 1916 "parser.yy" +#line 1917 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD ); @@ -7702,5 +7702,5 @@ /* Line 1806 of yacc.c */ -#line 1921 "parser.yy" +#line 1922 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG ); @@ -7712,5 +7712,5 @@ /* Line 1806 of yacc.c */ -#line 1929 "parser.yy" +#line 1930 "parser.yy" { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID ); @@ -7722,5 +7722,5 @@ /* Line 1806 of yacc.c */ -#line 1934 "parser.yy" +#line 1935 "parser.yy" { typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) ); @@ -7732,5 +7732,5 @@ /* Line 1806 of yacc.c */ -#line 1939 "parser.yy" +#line 1940 "parser.yy" { typedefTable.leaveTrait(); @@ -7743,5 +7743,5 @@ /* Line 1806 of yacc.c */ -#line 1949 "parser.yy" +#line 1950 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); } break; @@ -7750,5 +7750,5 @@ /* Line 1806 of yacc.c */ -#line 1959 "parser.yy" +#line 1960 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7760,5 +7760,5 @@ /* Line 1806 of yacc.c */ -#line 1964 "parser.yy" +#line 1965 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7770,5 +7770,5 @@ /* Line 1806 of yacc.c */ -#line 1969 "parser.yy" +#line 1970 "parser.yy" { typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID ); @@ -7780,5 +7780,5 @@ /* Line 1806 of yacc.c */ -#line 1977 "parser.yy" +#line 1978 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7790,5 +7790,5 @@ /* Line 1806 of yacc.c */ -#line 1982 "parser.yy" +#line 1983 "parser.yy" { typedefTable.addToEnclosingScope2( TypedefTable::ID ); @@ -7800,5 +7800,5 @@ /* Line 1806 of yacc.c */ -#line 1992 "parser.yy" +#line 1993 "parser.yy" {} break; @@ -7807,5 +7807,5 @@ /* Line 1806 of yacc.c */ -#line 1994 "parser.yy" +#line 1995 "parser.yy" { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl); } break; @@ -7814,5 +7814,5 @@ /* Line 1806 of yacc.c */ -#line 2000 "parser.yy" +#line 2001 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); } break; @@ -7821,5 +7821,5 @@ /* Line 1806 of yacc.c */ -#line 2005 "parser.yy" +#line 2006 "parser.yy" { (yyval.decl) = 0; } break; @@ -7828,5 +7828,5 @@ /* Line 1806 of yacc.c */ -#line 2013 "parser.yy" +#line 2014 "parser.yy" {} break; @@ -7835,5 +7835,5 @@ /* Line 1806 of yacc.c */ -#line 2015 "parser.yy" +#line 2016 "parser.yy" { linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" @@ -7845,5 +7845,5 @@ /* Line 1806 of yacc.c */ -#line 2020 "parser.yy" +#line 2021 "parser.yy" { linkage = linkageStack.top(); @@ -7856,5 +7856,5 @@ /* Line 1806 of yacc.c */ -#line 2026 "parser.yy" +#line 2027 "parser.yy" { // mark all fields in list for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) @@ -7867,5 +7867,5 @@ /* Line 1806 of yacc.c */ -#line 2041 "parser.yy" +#line 2042 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7878,5 +7878,5 @@ /* Line 1806 of yacc.c */ -#line 2047 "parser.yy" +#line 2048 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7889,5 +7889,5 @@ /* Line 1806 of yacc.c */ -#line 2056 "parser.yy" +#line 2057 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7900,5 +7900,5 @@ /* Line 1806 of yacc.c */ -#line 2062 "parser.yy" +#line 2063 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7911,5 +7911,5 @@ /* Line 1806 of yacc.c */ -#line 2068 "parser.yy" +#line 2069 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7922,5 +7922,5 @@ /* Line 1806 of yacc.c */ -#line 2074 "parser.yy" +#line 2075 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7933,5 +7933,5 @@ /* Line 1806 of yacc.c */ -#line 2080 "parser.yy" +#line 2081 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7944,5 +7944,5 @@ /* Line 1806 of yacc.c */ -#line 2088 "parser.yy" +#line 2089 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7955,5 +7955,5 @@ /* Line 1806 of yacc.c */ -#line 2094 "parser.yy" +#line 2095 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7966,5 +7966,5 @@ /* Line 1806 of yacc.c */ -#line 2102 "parser.yy" +#line 2103 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7977,5 +7977,5 @@ /* Line 1806 of yacc.c */ -#line 2108 "parser.yy" +#line 2109 "parser.yy" { typedefTable.addToEnclosingScope( TypedefTable::ID ); @@ -7988,5 +7988,5 @@ /* Line 1806 of yacc.c */ -#line 2123 "parser.yy" +#line 2124 "parser.yy" { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); } break; @@ -7995,5 +7995,5 @@ /* Line 1806 of yacc.c */ -#line 2128 "parser.yy" +#line 2129 "parser.yy" { delete (yyvsp[(3) - (5)].str); } break; @@ -8002,5 +8002,5 @@ /* Line 1806 of yacc.c */ -#line 2133 "parser.yy" +#line 2134 "parser.yy" { (yyval.decl) = 0; } break; @@ -8009,5 +8009,5 @@ /* Line 1806 of yacc.c */ -#line 2140 "parser.yy" +#line 2141 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -8016,5 +8016,5 @@ /* Line 1806 of yacc.c */ -#line 2146 "parser.yy" +#line 2147 "parser.yy" { (yyval.decl) = 0; } break; @@ -8023,5 +8023,5 @@ /* Line 1806 of yacc.c */ -#line 2157 "parser.yy" +#line 2158 "parser.yy" { delete (yyvsp[(3) - (4)].en); } break; @@ -8030,16 +8030,9 @@ /* Line 1806 of yacc.c */ -#line 2161 "parser.yy" +#line 2162 "parser.yy" { delete (yyvsp[(1) - (1)].tok); } break; case 560: - -/* Line 1806 of yacc.c */ -#line 2162 "parser.yy" - { delete (yyvsp[(1) - (1)].decl); } - break; - - case 561: /* Line 1806 of yacc.c */ @@ -8048,5 +8041,5 @@ break; - case 562: + case 561: /* Line 1806 of yacc.c */ @@ -8055,8 +8048,15 @@ break; + case 562: + +/* Line 1806 of yacc.c */ +#line 2165 "parser.yy" + { delete (yyvsp[(1) - (1)].decl); } + break; + case 563: /* Line 1806 of yacc.c */ -#line 2199 "parser.yy" +#line 2200 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8065,5 +8065,5 @@ /* Line 1806 of yacc.c */ -#line 2202 "parser.yy" +#line 2203 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8072,5 +8072,5 @@ /* Line 1806 of yacc.c */ -#line 2204 "parser.yy" +#line 2205 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8079,5 +8079,5 @@ /* Line 1806 of yacc.c */ -#line 2209 "parser.yy" +#line 2210 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8089,5 +8089,5 @@ /* Line 1806 of yacc.c */ -#line 2214 "parser.yy" +#line 2215 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8096,5 +8096,5 @@ /* Line 1806 of yacc.c */ -#line 2219 "parser.yy" +#line 2220 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8103,5 +8103,5 @@ /* Line 1806 of yacc.c */ -#line 2221 "parser.yy" +#line 2222 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8110,5 +8110,5 @@ /* Line 1806 of yacc.c */ -#line 2223 "parser.yy" +#line 2224 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8117,5 +8117,5 @@ /* Line 1806 of yacc.c */ -#line 2228 "parser.yy" +#line 2229 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; @@ -8124,5 +8124,5 @@ /* Line 1806 of yacc.c */ -#line 2230 "parser.yy" +#line 2231 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8131,5 +8131,5 @@ /* Line 1806 of yacc.c */ -#line 2232 "parser.yy" +#line 2233 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8138,5 +8138,5 @@ /* Line 1806 of yacc.c */ -#line 2234 "parser.yy" +#line 2235 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8145,5 +8145,5 @@ /* Line 1806 of yacc.c */ -#line 2239 "parser.yy" +#line 2240 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8152,5 +8152,5 @@ /* Line 1806 of yacc.c */ -#line 2241 "parser.yy" +#line 2242 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8159,5 +8159,5 @@ /* Line 1806 of yacc.c */ -#line 2250 "parser.yy" +#line 2251 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8166,5 +8166,5 @@ /* Line 1806 of yacc.c */ -#line 2253 "parser.yy" +#line 2254 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8173,5 +8173,5 @@ /* Line 1806 of yacc.c */ -#line 2258 "parser.yy" +#line 2259 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; @@ -8180,5 +8180,5 @@ /* Line 1806 of yacc.c */ -#line 2260 "parser.yy" +#line 2261 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8187,5 +8187,5 @@ /* Line 1806 of yacc.c */ -#line 2262 "parser.yy" +#line 2263 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8194,5 +8194,5 @@ /* Line 1806 of yacc.c */ -#line 2267 "parser.yy" +#line 2268 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8201,5 +8201,5 @@ /* Line 1806 of yacc.c */ -#line 2269 "parser.yy" +#line 2270 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8208,5 +8208,5 @@ /* Line 1806 of yacc.c */ -#line 2271 "parser.yy" +#line 2272 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8215,5 +8215,5 @@ /* Line 1806 of yacc.c */ -#line 2276 "parser.yy" +#line 2277 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8222,5 +8222,5 @@ /* Line 1806 of yacc.c */ -#line 2278 "parser.yy" +#line 2279 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8229,5 +8229,5 @@ /* Line 1806 of yacc.c */ -#line 2280 "parser.yy" +#line 2281 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8236,5 +8236,5 @@ /* Line 1806 of yacc.c */ -#line 2295 "parser.yy" +#line 2296 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); } break; @@ -8243,5 +8243,5 @@ /* Line 1806 of yacc.c */ -#line 2297 "parser.yy" +#line 2298 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); } break; @@ -8250,5 +8250,5 @@ /* Line 1806 of yacc.c */ -#line 2299 "parser.yy" +#line 2300 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8257,5 +8257,5 @@ /* Line 1806 of yacc.c */ -#line 2304 "parser.yy" +#line 2305 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8264,5 +8264,5 @@ /* Line 1806 of yacc.c */ -#line 2306 "parser.yy" +#line 2307 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8271,5 +8271,5 @@ /* Line 1806 of yacc.c */ -#line 2308 "parser.yy" +#line 2309 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8278,5 +8278,5 @@ /* Line 1806 of yacc.c */ -#line 2313 "parser.yy" +#line 2314 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8285,5 +8285,5 @@ /* Line 1806 of yacc.c */ -#line 2315 "parser.yy" +#line 2316 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8292,5 +8292,5 @@ /* Line 1806 of yacc.c */ -#line 2317 "parser.yy" +#line 2318 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8299,5 +8299,5 @@ /* Line 1806 of yacc.c */ -#line 2332 "parser.yy" +#line 2333 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8306,5 +8306,5 @@ /* Line 1806 of yacc.c */ -#line 2335 "parser.yy" +#line 2336 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8313,5 +8313,5 @@ /* Line 1806 of yacc.c */ -#line 2337 "parser.yy" +#line 2338 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8320,5 +8320,5 @@ /* Line 1806 of yacc.c */ -#line 2343 "parser.yy" +#line 2344 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8327,5 +8327,5 @@ /* Line 1806 of yacc.c */ -#line 2348 "parser.yy" +#line 2349 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8334,5 +8334,5 @@ /* Line 1806 of yacc.c */ -#line 2350 "parser.yy" +#line 2351 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8341,5 +8341,5 @@ /* Line 1806 of yacc.c */ -#line 2352 "parser.yy" +#line 2353 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8348,5 +8348,5 @@ /* Line 1806 of yacc.c */ -#line 2357 "parser.yy" +#line 2358 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; @@ -8355,5 +8355,5 @@ /* Line 1806 of yacc.c */ -#line 2359 "parser.yy" +#line 2360 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8362,5 +8362,5 @@ /* Line 1806 of yacc.c */ -#line 2361 "parser.yy" +#line 2362 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8369,5 +8369,5 @@ /* Line 1806 of yacc.c */ -#line 2363 "parser.yy" +#line 2364 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8376,5 +8376,5 @@ /* Line 1806 of yacc.c */ -#line 2368 "parser.yy" +#line 2369 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; @@ -8383,5 +8383,5 @@ /* Line 1806 of yacc.c */ -#line 2370 "parser.yy" +#line 2371 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8390,5 +8390,5 @@ /* Line 1806 of yacc.c */ -#line 2372 "parser.yy" +#line 2373 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8397,5 +8397,5 @@ /* Line 1806 of yacc.c */ -#line 2382 "parser.yy" +#line 2383 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8404,5 +8404,5 @@ /* Line 1806 of yacc.c */ -#line 2385 "parser.yy" +#line 2386 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8411,5 +8411,5 @@ /* Line 1806 of yacc.c */ -#line 2387 "parser.yy" +#line 2388 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8418,5 +8418,5 @@ /* Line 1806 of yacc.c */ -#line 2392 "parser.yy" +#line 2393 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8425,5 +8425,5 @@ /* Line 1806 of yacc.c */ -#line 2394 "parser.yy" +#line 2395 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8432,5 +8432,5 @@ /* Line 1806 of yacc.c */ -#line 2396 "parser.yy" +#line 2397 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8439,5 +8439,5 @@ /* Line 1806 of yacc.c */ -#line 2401 "parser.yy" +#line 2402 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; @@ -8446,5 +8446,5 @@ /* Line 1806 of yacc.c */ -#line 2403 "parser.yy" +#line 2404 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8453,5 +8453,5 @@ /* Line 1806 of yacc.c */ -#line 2405 "parser.yy" +#line 2406 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8460,5 +8460,5 @@ /* Line 1806 of yacc.c */ -#line 2407 "parser.yy" +#line 2408 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8467,5 +8467,5 @@ /* Line 1806 of yacc.c */ -#line 2412 "parser.yy" +#line 2413 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; @@ -8474,5 +8474,5 @@ /* Line 1806 of yacc.c */ -#line 2414 "parser.yy" +#line 2415 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8481,5 +8481,5 @@ /* Line 1806 of yacc.c */ -#line 2416 "parser.yy" +#line 2417 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8488,5 +8488,5 @@ /* Line 1806 of yacc.c */ -#line 2447 "parser.yy" +#line 2448 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8495,5 +8495,5 @@ /* Line 1806 of yacc.c */ -#line 2450 "parser.yy" +#line 2451 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8502,5 +8502,5 @@ /* Line 1806 of yacc.c */ -#line 2452 "parser.yy" +#line 2453 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8509,5 +8509,5 @@ /* Line 1806 of yacc.c */ -#line 2457 "parser.yy" +#line 2458 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8519,5 +8519,5 @@ /* Line 1806 of yacc.c */ -#line 2462 "parser.yy" +#line 2463 "parser.yy" { typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) ); @@ -8529,5 +8529,5 @@ /* Line 1806 of yacc.c */ -#line 2470 "parser.yy" +#line 2471 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8536,5 +8536,5 @@ /* Line 1806 of yacc.c */ -#line 2472 "parser.yy" +#line 2473 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8543,5 +8543,5 @@ /* Line 1806 of yacc.c */ -#line 2474 "parser.yy" +#line 2475 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8550,5 +8550,5 @@ /* Line 1806 of yacc.c */ -#line 2479 "parser.yy" +#line 2480 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; @@ -8557,5 +8557,5 @@ /* Line 1806 of yacc.c */ -#line 2481 "parser.yy" +#line 2482 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8564,5 +8564,5 @@ /* Line 1806 of yacc.c */ -#line 2486 "parser.yy" +#line 2487 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); } break; @@ -8571,5 +8571,5 @@ /* Line 1806 of yacc.c */ -#line 2488 "parser.yy" +#line 2489 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8578,5 +8578,5 @@ /* Line 1806 of yacc.c */ -#line 2503 "parser.yy" +#line 2504 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8585,5 +8585,5 @@ /* Line 1806 of yacc.c */ -#line 2505 "parser.yy" +#line 2506 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8592,5 +8592,5 @@ /* Line 1806 of yacc.c */ -#line 2510 "parser.yy" +#line 2511 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; @@ -8599,5 +8599,5 @@ /* Line 1806 of yacc.c */ -#line 2512 "parser.yy" +#line 2513 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; @@ -8606,5 +8606,5 @@ /* Line 1806 of yacc.c */ -#line 2514 "parser.yy" +#line 2515 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8613,5 +8613,5 @@ /* Line 1806 of yacc.c */ -#line 2516 "parser.yy" +#line 2517 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8620,5 +8620,5 @@ /* Line 1806 of yacc.c */ -#line 2518 "parser.yy" +#line 2519 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8627,5 +8627,5 @@ /* Line 1806 of yacc.c */ -#line 2524 "parser.yy" +#line 2525 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8634,5 +8634,5 @@ /* Line 1806 of yacc.c */ -#line 2526 "parser.yy" +#line 2527 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8641,5 +8641,5 @@ /* Line 1806 of yacc.c */ -#line 2528 "parser.yy" +#line 2529 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8648,5 +8648,5 @@ /* Line 1806 of yacc.c */ -#line 2533 "parser.yy" +#line 2534 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } break; @@ -8655,5 +8655,5 @@ /* Line 1806 of yacc.c */ -#line 2535 "parser.yy" +#line 2536 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8662,5 +8662,5 @@ /* Line 1806 of yacc.c */ -#line 2537 "parser.yy" +#line 2538 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8669,5 +8669,5 @@ /* Line 1806 of yacc.c */ -#line 2543 "parser.yy" +#line 2544 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; @@ -8676,5 +8676,5 @@ /* Line 1806 of yacc.c */ -#line 2545 "parser.yy" +#line 2546 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); } break; @@ -8683,5 +8683,5 @@ /* Line 1806 of yacc.c */ -#line 2551 "parser.yy" +#line 2552 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); } break; @@ -8690,5 +8690,5 @@ /* Line 1806 of yacc.c */ -#line 2553 "parser.yy" +#line 2554 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( 0 ); } break; @@ -8697,5 +8697,5 @@ /* Line 1806 of yacc.c */ -#line 2555 "parser.yy" +#line 2556 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); } break; @@ -8704,5 +8704,5 @@ /* Line 1806 of yacc.c */ -#line 2557 "parser.yy" +#line 2558 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); } break; @@ -8711,5 +8711,5 @@ /* Line 1806 of yacc.c */ -#line 2572 "parser.yy" +#line 2573 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8718,5 +8718,5 @@ /* Line 1806 of yacc.c */ -#line 2574 "parser.yy" +#line 2575 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8725,5 +8725,5 @@ /* Line 1806 of yacc.c */ -#line 2579 "parser.yy" +#line 2580 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; @@ -8732,5 +8732,5 @@ /* Line 1806 of yacc.c */ -#line 2581 "parser.yy" +#line 2582 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; @@ -8739,5 +8739,5 @@ /* Line 1806 of yacc.c */ -#line 2583 "parser.yy" +#line 2584 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8746,5 +8746,5 @@ /* Line 1806 of yacc.c */ -#line 2585 "parser.yy" +#line 2586 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8753,5 +8753,5 @@ /* Line 1806 of yacc.c */ -#line 2587 "parser.yy" +#line 2588 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8760,5 +8760,5 @@ /* Line 1806 of yacc.c */ -#line 2593 "parser.yy" +#line 2594 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8767,5 +8767,5 @@ /* Line 1806 of yacc.c */ -#line 2595 "parser.yy" +#line 2596 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8774,5 +8774,5 @@ /* Line 1806 of yacc.c */ -#line 2597 "parser.yy" +#line 2598 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8781,5 +8781,5 @@ /* Line 1806 of yacc.c */ -#line 2602 "parser.yy" +#line 2603 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); } break; @@ -8788,5 +8788,5 @@ /* Line 1806 of yacc.c */ -#line 2604 "parser.yy" +#line 2605 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8795,5 +8795,5 @@ /* Line 1806 of yacc.c */ -#line 2606 "parser.yy" +#line 2607 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8802,5 +8802,5 @@ /* Line 1806 of yacc.c */ -#line 2613 "parser.yy" +#line 2614 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); } break; @@ -8809,5 +8809,5 @@ /* Line 1806 of yacc.c */ -#line 2624 "parser.yy" +#line 2625 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); } break; @@ -8816,5 +8816,5 @@ /* Line 1806 of yacc.c */ -#line 2627 "parser.yy" +#line 2628 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; @@ -8823,5 +8823,5 @@ /* Line 1806 of yacc.c */ -#line 2629 "parser.yy" +#line 2630 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); } break; @@ -8830,5 +8830,5 @@ /* Line 1806 of yacc.c */ -#line 2632 "parser.yy" +#line 2633 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; @@ -8837,5 +8837,5 @@ /* Line 1806 of yacc.c */ -#line 2634 "parser.yy" +#line 2635 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); } break; @@ -8844,5 +8844,5 @@ /* Line 1806 of yacc.c */ -#line 2636 "parser.yy" +#line 2637 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); } break; @@ -8851,5 +8851,5 @@ /* Line 1806 of yacc.c */ -#line 2650 "parser.yy" +#line 2651 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8858,5 +8858,5 @@ /* Line 1806 of yacc.c */ -#line 2652 "parser.yy" +#line 2653 "parser.yy" { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); } break; @@ -8865,5 +8865,5 @@ /* Line 1806 of yacc.c */ -#line 2657 "parser.yy" +#line 2658 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( 0 ); } break; @@ -8872,5 +8872,5 @@ /* Line 1806 of yacc.c */ -#line 2659 "parser.yy" +#line 2660 "parser.yy" { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); } break; @@ -8879,5 +8879,5 @@ /* Line 1806 of yacc.c */ -#line 2661 "parser.yy" +#line 2662 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8886,5 +8886,5 @@ /* Line 1806 of yacc.c */ -#line 2663 "parser.yy" +#line 2664 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); } break; @@ -8893,5 +8893,5 @@ /* Line 1806 of yacc.c */ -#line 2665 "parser.yy" +#line 2666 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8900,5 +8900,5 @@ /* Line 1806 of yacc.c */ -#line 2671 "parser.yy" +#line 2672 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8907,5 +8907,5 @@ /* Line 1806 of yacc.c */ -#line 2673 "parser.yy" +#line 2674 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); } break; @@ -8914,5 +8914,5 @@ /* Line 1806 of yacc.c */ -#line 2675 "parser.yy" +#line 2676 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8921,5 +8921,5 @@ /* Line 1806 of yacc.c */ -#line 2680 "parser.yy" +#line 2681 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); } break; @@ -8928,5 +8928,5 @@ /* Line 1806 of yacc.c */ -#line 2682 "parser.yy" +#line 2683 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (3)].decl); } break; @@ -8935,5 +8935,5 @@ /* Line 1806 of yacc.c */ -#line 2692 "parser.yy" +#line 2693 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -8942,5 +8942,5 @@ /* Line 1806 of yacc.c */ -#line 2702 "parser.yy" +#line 2703 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8949,5 +8949,5 @@ /* Line 1806 of yacc.c */ -#line 2704 "parser.yy" +#line 2705 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -8956,5 +8956,5 @@ /* Line 1806 of yacc.c */ -#line 2706 "parser.yy" +#line 2707 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8963,5 +8963,5 @@ /* Line 1806 of yacc.c */ -#line 2708 "parser.yy" +#line 2709 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -8970,5 +8970,5 @@ /* Line 1806 of yacc.c */ -#line 2710 "parser.yy" +#line 2711 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -8977,5 +8977,5 @@ /* Line 1806 of yacc.c */ -#line 2712 "parser.yy" +#line 2713 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -8984,5 +8984,5 @@ /* Line 1806 of yacc.c */ -#line 2719 "parser.yy" +#line 2720 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; @@ -8991,5 +8991,5 @@ /* Line 1806 of yacc.c */ -#line 2721 "parser.yy" +#line 2722 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; @@ -8998,5 +8998,5 @@ /* Line 1806 of yacc.c */ -#line 2723 "parser.yy" +#line 2724 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; @@ -9005,5 +9005,5 @@ /* Line 1806 of yacc.c */ -#line 2725 "parser.yy" +#line 2726 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; @@ -9012,5 +9012,5 @@ /* Line 1806 of yacc.c */ -#line 2727 "parser.yy" +#line 2728 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; @@ -9019,5 +9019,5 @@ /* Line 1806 of yacc.c */ -#line 2729 "parser.yy" +#line 2731 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; @@ -9026,5 +9026,5 @@ /* Line 1806 of yacc.c */ -#line 2731 "parser.yy" +#line 2733 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; @@ -9033,5 +9033,5 @@ /* Line 1806 of yacc.c */ -#line 2733 "parser.yy" +#line 2735 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); } break; @@ -9040,5 +9040,5 @@ /* Line 1806 of yacc.c */ -#line 2735 "parser.yy" +#line 2737 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); } break; @@ -9047,5 +9047,5 @@ /* Line 1806 of yacc.c */ -#line 2737 "parser.yy" +#line 2739 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; @@ -9054,5 +9054,5 @@ /* Line 1806 of yacc.c */ -#line 2742 "parser.yy" +#line 2744 "parser.yy" { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); } break; @@ -9061,5 +9061,5 @@ /* Line 1806 of yacc.c */ -#line 2744 "parser.yy" +#line 2746 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); } break; @@ -9068,5 +9068,5 @@ /* Line 1806 of yacc.c */ -#line 2749 "parser.yy" +#line 2751 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); } break; @@ -9075,5 +9075,5 @@ /* Line 1806 of yacc.c */ -#line 2751 "parser.yy" +#line 2753 "parser.yy" { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); } break; @@ -9082,5 +9082,5 @@ /* Line 1806 of yacc.c */ -#line 2778 "parser.yy" +#line 2780 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); } break; @@ -9089,5 +9089,5 @@ /* Line 1806 of yacc.c */ -#line 2789 "parser.yy" +#line 2791 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -9096,5 +9096,5 @@ /* Line 1806 of yacc.c */ -#line 2791 "parser.yy" +#line 2793 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -9103,5 +9103,5 @@ /* Line 1806 of yacc.c */ -#line 2793 "parser.yy" +#line 2795 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -9110,5 +9110,5 @@ /* Line 1806 of yacc.c */ -#line 2795 "parser.yy" +#line 2797 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -9117,5 +9117,5 @@ /* Line 1806 of yacc.c */ -#line 2797 "parser.yy" +#line 2799 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); } break; @@ -9124,5 +9124,5 @@ /* Line 1806 of yacc.c */ -#line 2799 "parser.yy" +#line 2801 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); } break; @@ -9131,5 +9131,5 @@ /* Line 1806 of yacc.c */ -#line 2806 "parser.yy" +#line 2808 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } break; @@ -9138,5 +9138,5 @@ /* Line 1806 of yacc.c */ -#line 2808 "parser.yy" +#line 2810 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } break; @@ -9145,5 +9145,5 @@ /* Line 1806 of yacc.c */ -#line 2810 "parser.yy" +#line 2812 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; @@ -9152,5 +9152,5 @@ /* Line 1806 of yacc.c */ -#line 2812 "parser.yy" +#line 2814 "parser.yy" { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } break; @@ -9159,5 +9159,5 @@ /* Line 1806 of yacc.c */ -#line 2814 "parser.yy" +#line 2816 "parser.yy" { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); } break; @@ -9166,5 +9166,5 @@ /* Line 1806 of yacc.c */ -#line 2816 "parser.yy" +#line 2818 "parser.yy" { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); } break; @@ -9173,5 +9173,5 @@ /* Line 1806 of yacc.c */ -#line 2821 "parser.yy" +#line 2823 "parser.yy" { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); } break; @@ -9180,16 +9180,9 @@ /* Line 1806 of yacc.c */ -#line 2826 "parser.yy" +#line 2828 "parser.yy" { (yyval.decl) = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), (yyvsp[(4) - (5)].decl), nullptr ); } break; case 749: - -/* Line 1806 of yacc.c */ -#line 2828 "parser.yy" - { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } - break; - - case 750: /* Line 1806 of yacc.c */ @@ -9198,8 +9191,15 @@ break; + case 750: + +/* Line 1806 of yacc.c */ +#line 2832 "parser.yy" + { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); } + break; + case 753: /* Line 1806 of yacc.c */ -#line 2854 "parser.yy" +#line 2856 "parser.yy" { (yyval.en) = 0; } break; @@ -9208,5 +9208,5 @@ /* Line 1806 of yacc.c */ -#line 2856 "parser.yy" +#line 2858 "parser.yy" { (yyval.en) = (yyvsp[(2) - (2)].en); } break; @@ -9446,5 +9446,5 @@ /* Line 2067 of yacc.c */ -#line 2859 "parser.yy" +#line 2861 "parser.yy" // ----end of grammar---- Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision f0121d7b1fdcae6c3362d9920d387c2a83a180d7) +++ src/Parser/parser.yy (revision a1e67ddc023331e04cc5481931be1d0923efc441) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Oct 5 14:10:46 2016 -// Update Count : 2002 +// Last Modified On : Wed Oct 19 22:19:33 2016 +// Update Count : 2003 // @@ -277,10 +277,10 @@ // // Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those -// introduced through "forall" qualifiers), and by introducing "type generators" -- parametrized types. This latter +// introduced through "forall" qualifiers), and by introducing "type generators" -- parameterized types. This latter // type name creates a third class of identifiers that must be distinguished by the scanner. // // Since the scanner cannot distinguish among the different classes of identifiers without some context information, it -// accesses a data structure (the TypedefTable) to allow classification of an identifier that it has just read. -// Semantic actions during the parser update this data structure when the class of identifiers change. +// accesses a data structure (TypedefTable) to allow classification of an identifier that it has just read. Semantic +// actions during the parser update this data structure when the class of identifiers change. // // Because the Cforall language is block-scoped, there is the possibility that an identifier can change its class in a @@ -288,5 +288,5 @@ // particular declaration, each declaration is itself a scope. This requires distinguishing between type names that are // local to the current declaration scope and those that persist past the end of the declaration (i.e., names defined in -// "typedef" or "type" declarations). +// "typedef" or "otype" declarations). // // The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and closing of @@ -433,4 +433,5 @@ no_attr_identifier { $$ = new ExpressionNode( build_varref( $1 ) ); } + // x.1, x.[0, 0.0] | INTEGERconstant { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); } @@ -2726,4 +2727,5 @@ | multi_array_dimension type_specifier { $$ = $2->addNewArray( $1 ); } + | '[' ']' new_identifier_parameter_ptr { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }