Changeset becba789


Ignore:
Timestamp:
Aug 2, 2016, 6:40:20 PM (9 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
8a443f4, 9799ec8
Parents:
e4957e7 (diff), 155cce0f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:
14 edited

Legend:

Unmodified
Added
Removed
  • INSTALL

    re4957e7 rbecba789  
    33
    44Cforall is built using GNU Make and the GNU Autoconf system.  It also requires
    5 g++ version 4, bison and flex.  On systems where GNU Make is the default make
    6 it may suffice to build the system by entering the commands
     5g++ version >= 4.6, bison and flex.  On systems where GNU Make is the default
     6make, the system is built by entering the commands:
    77
    88        ./configure
     
    1717
    1818--prefix=/some/directory controls the path prefix common to all installed
    19   cfa-cc components.  Some components will be installed in /some/directory/bin,
     19  cfa-cc components.  Some components are installed in /some/directory/bin,
    2020  others in /some/directory/lib.  If unspecified, this defaults to /usr/local.
    21   If you wish to use (a subdirectory of) your home directory, ${HOME}/some/dir
    22   works, but it is important not to put quotes around the directory path;
    23   Cforall may appear to build, but the installed version may not work properly.
     21  To use (a subdirectory of) your home directory, ${HOME}/some/dir works, but
     22  it is important not to put quotes around the directory path; Cforall may
     23  appear to build, but the installed version may not work properly.
    2424
    2525--with-backend-compiler=PROGRAM specifies the installed path of gcc.  It
  • Jenkins/FullBuild

    re4957e7 rbecba789  
    4343                }
    4444
    45                 sh "GIT_SSH_COMMAND=\"ssh -v\" git push DoLang ${gitRefNewValue}:master"
     45                //sh "GIT_SSH_COMMAND=\"ssh -v\" git push DoLang ${gitRefNewValue}:master"
     46                echo('BUILD NOT PUSH SINCE DO-LANG SERVER WAS DOWN')
    4647}
    4748
     
    6768
    6869node ('master') {
     70        def err = null
     71
    6972        try {
    7073                //Prevent the build from exceeding 30 minutes
     
    7881                                        results = [null, null]
    7982
    80                                         // parallel (
    81                                         //      x64: {
    82                                         //              trigger_build('64-bit')
    83                                         //      },
    84                                         //      x32: {
    85                                         //              trigger_build('32-bit')
    86                                         //      }
    87                                         // )
     83                                        parallel (
     84                                                x64: {
     85                                                        trigger_build('64-bit')
     86                                                },
     87                                                x32: {
     88                                                        trigger_build('32-bit')
     89                                                }
     90                                        )
    8891
    8992                                //Push latest changes to do-lang repo
  • doc/LaTeXmacros/common.tex

    re4957e7 rbecba789  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Tue Jul 12 20:37:57 2016
    14 %% Update Count     : 206
     13%% Last Modified On : Mon Aug  1 09:11:20 2016
     14%% Update Count     : 225
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    16 
    17 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1816
    1917\setlength{\textheight}{9in}
    2018%\oddsidemargin 0.0in
    21 \renewcommand{\topfraction}{0.8}        % float must be greater than X of the page before it is forced onto its own page
    22 \renewcommand{\bottomfraction}{0.8}     % float must be greater than X of the page before it is forced onto its own page
     19\renewcommand{\topfraction}{0.8}                % float must be greater than X of the page before it is forced onto its own page
     20\renewcommand{\bottomfraction}{0.8}             % float must be greater than X of the page before it is forced onto its own page
    2321\renewcommand{\floatpagefraction}{0.8}  % float must be greater than X of the page before it is forced onto its own page
    24 \renewcommand{\textfraction}{0.0}       % the entire page maybe devoted to floats with no text on the page at all
    25 
    26 \lefthyphenmin=4
     22\renewcommand{\textfraction}{0.0}               % the entire page maybe devoted to floats with no text on the page at all
     23
     24\lefthyphenmin=4                                                % hyphen only after 4 characters
    2725\righthyphenmin=4
    2826
     
    3836% Names used in the document.
    3937
    40 \newcommand{\CFA}{C$\mathbf\forall$\xspace}              % set language symbolic name
    41 \newcommand{\CFL}{Cforall\xspace}                        % set language text name
     38\newcommand{\CFA}{C$\mathbf\forall$\xspace} % set language symbolic name
     39\newcommand{\CFL}{Cforall\xspace}               % set language text name
    4240\newcommand{\CC}{\rm C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
    4341\newcommand{\CCeleven}{\rm C\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
    44 \def\c11{ISO/IEC C} % C11 name (cannot have numbers in latex command name)
     42\def\c11{ISO/IEC C}                                             % C11 name (cannot have numbers in latex command name)
    4543
    4644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
    5250\setlength{\parindentlnth}{\parindent}
    5351
    54 \newlength{\gcolumnposn}
     52\newlength{\gcolumnposn}                                % temporary hack because lstlisting does handle tabs correctly
    5553\newlength{\columnposn}
    5654\setlength{\gcolumnposn}{2.5in}
     
    6361%\patchcmd{\lsthk@TextStyle}{\let\lst@DefEsc\@empty}{}{}{\errmessage{failed to patch}}
    6462
    65 \usepackage{pslatex}                                                                    % reduce size of san serif font
    66 \usepackage{relsize}                                    % must be after change to small or selects old size
     63\usepackage{pslatex}                                    % reduce size of san serif font
     64\usepackage{relsize}                                    % must be after change to small or selects old size
    6765
    6866% reduce size of chapter/section titles
     
    120118
    121119% inline text and lowercase index: \Index{inline and lowercase index text}
     120\newcommand{\Index}{\@ifstar\@sIndex\@Index}
    122121% inline text and as-in index: \Index[as-is index text]{inline text}
     122\newcommand{\@Index}[2][\@empty]{\lowercase{\def\temp{#2}}#2\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
    123123% inline text but index with different as-is text: \Index[index text]{inline text}
    124 \newcommand{\Index}{\@ifstar\@sIndex\@Index}
    125 \newcommand{\@Index}[2][\@empty]{\lowercase{\def\temp{#2}}#2\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
    126124\newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
    127125
    128 % cannot use ©
     126% inline text and code index (cannot use ©)
    129127\newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
     128% code index (cannot use ©)
    130129\newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
    131130
     
    137136\newcommand{\@newterm}[2][\@empty]{\lowercase{\def\temp{#2}}{\newtermFontInline{#2}}\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
    138137\newcommand{\@snewterm}[2][\@empty]{{\newtermFontInline{#2}}\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
     138
     139% Latin abbreviation
     140\newcommand{\abbrevFont}{\textit}       % set empty for no italics
     141\newcommand*{\eg}{%
     142        \@ifnextchar{,}{\abbrevFont{e}.\abbrevFont{g}.}%
     143                {\@ifnextchar{:}{\abbrevFont{e}.\abbrevFont{g}.}%
     144                        {\abbrevFont{e}.\abbrevFont{g}.,\xspace}}%
     145}%
     146\newcommand*{\ie}{%
     147        \@ifnextchar{,}{\abbrevFont{i}.\abbrevFont{e}.}%
     148                {\@ifnextchar{:}{\abbrevFont{i}.\abbrevFont{e}.}%
     149                        {\abbrevFont{i}.\abbrevFont{e}.,\xspace}}%
     150}%
     151\newcommand*{\etc}{%
     152        \@ifnextchar{.}{\abbrevFont{etc}}%
     153        {\abbrevFont{etc}.\xspace}%
     154}%
    139155\makeatother
    140156
     
    145161        \endlist
    146162}% quote2
     163
    147164\newenvironment{rationale}{%
    148165  \begin{quote2}\noindent$\Box$\enspace
     
    188205\newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}}
    189206
    190 % Go programming language
     207% Go programming language: https://github.com/julienc91/listings-golang/blob/master/listings-golang.sty
    191208\lstdefinelanguage{Golang}{
    192209        morekeywords=[1]{package,import,func,type,struct,return,defer,panic, recover,select,var,const,iota,},%
     
    204221}
    205222
    206 % CFA programming language, based on ANSI C
     223% CFA programming language, based on ANSI C (with some gcc additions)
    207224\lstdefinelanguage{CFA}[ANSI]{C}{
    208225        morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
    209226                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    210                 fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
     227                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
    211228                _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
    212229}%
     
    215232language=CFA,
    216233columns=fullflexible,
    217 basicstyle=\linespread{0.9}\sf,
    218 stringstyle=\tt,
    219 tabsize=4,
    220 xleftmargin=\parindentlnth,
    221 extendedchars=true,
    222 escapechar=§,
    223 mathescape=true,
    224 keepspaces=true,
    225 showstringspaces=false,
    226 showlines=true,
    227 aboveskip=4pt,
     234basicstyle=\linespread{0.9}\sf,                 % reduce line spacing and use sanserif font
     235stringstyle=\tt,                                                % use typewriter font
     236tabsize=4,                                                              % 4 space tabbing
     237xleftmargin=\parindentlnth,                             % indent code to paragraph indentation
     238extendedchars=true,                                             % allow ASCII characters in the range 128-255
     239escapechar=§,                                                   % escape to latex in CFA code
     240mathescape=true,                                                % allow $...$ LaTeX math escapes in code
     241%keepspaces=true,                                               %
     242showstringspaces=false,                                 % do not show spaces with cup
     243showlines=true,                                                 % show blank lines at end of code
     244aboveskip=4pt,                                                  % spacing above/below code block
    228245belowskip=3pt,
    229 moredelim=**[is][\color{red}]{®}{®}, % red highlighting
    230 moredelim=**[is][\color{blue}]{ß}{ß}, % blue highlighting
     246moredelim=**[is][\color{red}]{®}{®},    % red highlighting
     247moredelim=**[is][\color{blue}]{ß}{ß},   % blue highlighting
    231248moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting
    232249moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
     
    242259\renewcommand\thebibliography[1]{
    243260  \Oldthebibliography{#1}
    244   \setlength{\parskip}{0pt}                     % reduce vertical spacing between references
     261  \setlength{\parskip}{0pt}                             % reduce vertical spacing between references
    245262  \setlength{\itemsep}{5pt plus 0.3ex}
    246263}%
    247 
    248 \newcommand*{\eg}{\textit{e.g}.\@\xspace}
    249 \newcommand*{\ie}{\textit{i.e}.\@\xspace}
    250 
    251 \makeatletter
    252 \newcommand*{\etc}{%
    253     \@ifnextchar{.}%
    254         {\textit{etc}}%
    255         {\textit{etc}.\@\xspace}%
    256 }
    257 \makeatother
    258264
    259265% Local Variables: %
  • doc/aaron_comp_II/comp_II.tex

    re4957e7 rbecba789  
    4343%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    4444
    45 \title{\Huge
    46 \vspace*{1in}
    47 Efficient Type Resolution in \CFA \\
    48 \vspace*{0.25in}
    49 \huge
    50 PhD Comprehensive II Research Proposal
     45\title{
     46\Huge \vspace*{1in} Efficient Type Resolution in \CFA \\
     47\huge \vspace*{0.25in} PhD Comprehensive II Research Proposal
    5148\vspace*{1in}
    5249}
    5350
    54 \author{\huge
    55 \vspace*{0.1in}
    56 Aaron Moss \\
     51\author{
     52\huge Aaron Moss \\
     53\Large \vspace*{0.1in} \texttt{a3moss@uwaterloo.ca} \\
    5754\Large Cheriton School of Computer Science \\
    5855\Large University of Waterloo
     
    8885
    8986\CFA\footnote{Pronounced ``C-for-all'', and written \CFA, CFA, or \CFL.} is an evolutionary modernization of the C programming language currently being designed and built at the University of Waterloo by a team led by Peter Buhr.
    90 Features added to C by \CFA include name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others.
    91 These features make \CFA significantly more powerful and expressive than C, but impose a significant compile-time cost to implement, particularly in the expression resolver, which must evaluate the typing rules of a much more complex type system.
     87\CFA adds multiple features to C, including name overloading, user-defined operators, parametric-polymorphic routines, and type constructors and destructors, among others.
     88These features make \CFA significantly more powerful and expressive than C, but impose a significant compile-time cost to support, particularly in the expression resolver, which must evaluate the typing rules of a much more complex type system.
    9289The primary goal of this proposed research project is to develop a sufficiently performant expression resolution algorithm, experimentally validate its performance, and integrate it into \Index*{CFA-CC}, the \CFA reference compiler.
    9390Secondary goals of this project include the development of various new language features for \CFA; parametric-polymorphic (``generic'') types have already been designed and implemented, and reference types and user-defined conversions are under design consideration.
    94 The experimental performance-testing architecture for resolution algorithms will also be used to determine the compile-time cost of adding such new features to the \CFA type system.
     91The experimental performance-testing architecture for resolution algorithms will also be used to determine the compile-time cost of adding such new features to the \CFA type system.
     92More broadly, this research should provide valuable data for implementers of compilers for other programming languages with similarly powerful static type systems.
    9593
    9694\section{\CFA}
     
    10199\subsection{Polymorphic Functions}
    102100The most significant feature \CFA adds is parametric-polymorphic functions.
    103 Such functions are written using a ©forall© clause, the feature that gave the language its name:
     101Such functions are written using a ©forall© clause (which gives the language its name):
    104102\begin{lstlisting}
    105103forall(otype T)
     
    129127
    130128Monomorphic specializations of polymorphic functions can themselves be used to satisfy type assertions.
    131 For instance, ©twice© could have been define as below, using the \CFA syntax for operator overloading:
     129For instance, ©twice© could have been defined as below, using the \CFA syntax for operator overloading:
    132130\begin{lstlisting}
    133131forall(otype S | { S ?+?(S, S); })
     
    135133\end{lstlisting}
    136134This version of ©twice© will work for any type ©S© that has an addition operator defined for it, and it could have been used to satisfy the type assertion on ©four_times©.
    137 The compiler accomplishes this by creating a wrapper function calling ©twice // (2)© with ©S© bound to ©double©, then providing this wrapper function to ©four_times©\footnote{©twice // (2)© could have had a type parameter named ©T©; \CFA specifies a renaming the type parameters, which would avoid the name conflict with the parameter ©T© of ©four_times©.}.
     135The compiler accomplishes this by creating a wrapper function calling ©twice // (2)© with ©S© bound to ©double©, then providing this wrapper function to ©four_times©\footnote{©twice // (2)© could also have had a type parameter named ©T©; \CFA specifies renaming of the type parameters, which would avoid the name conflict with the type variable ©T© of ©four_times©.}.
    138136
    139137Finding appropriate functions to satisfy type assertions is essentially a recursive case of expression resolution, as it takes a name (that of the type assertion) and attempts to match it to a suitable declaration in the current scope.
    140138If a polymorphic function can be used to satisfy one of its own type assertions, this recursion may not terminate, as it is possible that function will be examined as a candidate for its own type assertion unboundedly repeatedly.
    141139To avoid infinite loops, the current \Index*{CFA-CC} compiler imposes a fixed limit on the possible depth of recursion, similar to that employed by most \Index*[C++]{\CC} compilers for template expansion; this restriction means that there are some semantically well-typed expressions which cannot be resolved by {CFA-CC}.
    142 One area of potential improvement this project proposes to investigate is the possibility of using the compiler's knowledge of the current set of declarations to make a more precise judgement of when further type assertion satisfaction recursion will not produce a well-typed expression.
     140One area of potential improvement this project proposes to investigate is the possibility of using the compiler's knowledge of the current set of declarations to more precicely determine when further type assertion satisfaction recursion will not produce a well-typed expression.
    143141
    144142\subsection{Name Overloading}
     
    171169Such a conversion system should be simple for user programmers to utilize, and fit naturally with the existing design of implicit conversions in C; ideally it would also be sufficiently powerful to encode C's usual arithmetic conversions itself, so that \CFA only has one set of rules for conversions.
    172170
    173 Glen Ditchfield \textbf{TODO CITE} has laid out a framework for using polymorphic conversion constructor functions to create a directed acyclic graph (DAG) of conversions.
     171Ditchfield\cite{Ditchfield:conversions} has laid out a framework for using polymorphic conversion constructor functions to create a directed acyclic graph (DAG) of conversions.
    174172A monomorphic variant of these functions can be used to mark a conversion arc in the DAG as only usable as the final step in a conversion.
    175173With these two types of conversion arcs, separate DAGs can be created for the safe and the unsafe conversions, and conversion cost can be represented as path length through the DAG.
     
    210208\CFA adds \emph{tuple types} to C, a facility for referring to multiple values with a single identifier.
    211209A variable may name a tuple, and a function may return one.
    212 Particularly relevantly for resolution, a tuple may be automatically \emph{destructured} into a list of values, as in the ©swap© function below:
     210Particularly relevantly for resolution, a tuple may be implicitly \emph{destructured} into a list of values, as in the call to ©swap© below:
    213211\begin{lstlisting}
    214212[char, char] x = [ '!', '?' ];
     
    218216
    219217x = swap( x ); // destructure [char, char] x into two elements of parameter list
    220 // ^ can't use int x for parameter, not enough arguments to swap
     218// can't use int x for parameter, not enough arguments to swap
    221219\end{lstlisting}
    222220Tuple destructuring means that the mapping from the position of a subexpression in the argument list to the position of a paramter in the function declaration is not straightforward, as some arguments may be expandable to different numbers of parameters, like ©x© above.
     
    245243
    246244\section{Expression Resolution}
    247 % TODO cite Baker, Cormack, etc.
    248 
     245The expression resolution problem is essentially to determine an optimal matching between some combination of argument interpretations and the parameter list of some overloaded instance of a function; the argument interpretations are produced by recursive invocations of expression resolution, where the base case is zero-argument functions (which are, for purposes of this discussion, semantically equivalent to named variables or constant literal expressions).
     246Assuming that the matching between a function's parameter list and a combination of argument interpretations can be done in $O(p^k)$ time, where $p$ is the number of parameters and $k$ is some positive number, if there are $O(i)$ valid interpretations for each subexpression, there will be $O(i)$ candidate functions and $O(i^p)$ possible argument combinations for each expression, so a single recursive call to expression resolution will take $O(i^{p+1} \cdot p^k)$ time if it compares all combinations.
     247Given this bound, resolution of a single top-level expression tree of depth $d$ takes $O(i^{p+1} \cdot p^{k \cdot d})$ time\footnote{The call tree will have leaves at depth $O(d)$, and each internal node will have $O(p)$ fan-out, producing $O(p^d)$ total recursive calls.}.
     248Expression resolution is somewhat unavoidably exponential in $p$, the number of function parameters, and $d$, the depth of the expression tree, but these values are fixed by the user programmer, and generally bounded by reasonably small constants.
     249$k$, on the other hand, is mostly dependent on the representation of types in the system and the efficiency of type assertion checking; if a candidate argument combination can be compared to a function parameter list in linear time in the length of the list (\ie $k = 1$), then the $p^{k \cdot d}$ term is linear in the input size of the source code for the expression, otherwise the resolution algorithm will exibit sub-linear performance scaling on code containing more-deeply nested expressions.
     250The number of valid interpretations of any subexpression, $i$, is bounded by the number of types in the system, which is possibly infinite, though practical resolution algorithms for \CFA must be able to place some finite bound on $i$, possibly at the expense of type system completeness.
     251
     252The research goal of this project is to develop a performant expression resolver for \CFA; this analysis suggests two primary areas of investigation to accomplish that end.
     253The first is efficient argument-parameter matching; Bilson\cite{Bilson03} mentions significant optimization opportunities available in the current literature to improve on the existing {CFA-CC} compiler.
     254%TODO: look up and lit review
     255The second, and likely more fruitful, area of investigation is heuristics and algorithmic approaches to reduce the number of argument interpretations considered in the common case; given the large ($p+1$) exponent on number of interpretations considered in the runtime analysis, even small reductions here could have a significant effect on overall resolver runtime.
     256The discussion below presents a number of largely orthagonal axes for expression resolution algorithm design to be investigated, noting prior work where applicable.
     257
     258\subsection{Argument-Parameter Matching}
     259The first axis we consider is argument-parameter matching --- whether the type matching for a candidate function to a set of candidate arguments is directed by the argument types or the parameter types.
     260
     261\subsubsection{Argument-directed (``Bottom-up'')}
     262Baker's algorithm for expression resolution\cite{Baker82} pre-computes argument candidates, from the leaves of the expression tree up.
     263For each candidate function, Baker attempts to match argument types to parameter types in sequence, failing if any parameter cannot be matched.
     264
     265Bilson\cite{Bilson03} similarly pre-computes argument candidates in the original \CFA compiler, but then explicitly enumerates all possible argument combinations for a multi-parameter function; these argument combinations are matched to the parameter types of the candidate function as a unit rather than individual arguments.
     266This is less efficient than Baker's approach, as the same argument may be compared to the same parameter many times, but allows a more straightforward handling of polymorphic type binding and multiple return types.
     267It is possible the efficiency losses here relative to Baker could be significantly reduced by application of memoization to the argument-parameter type comparisons.
     268
     269\subsubsection{Parameter-directed (``Top-down'')}
     270Unlike Baker and Bilson, Cormack's algorithm\cite{Cormack81} requests argument candidates which match the type of each parameter of each candidate function, from the top-level expression down; memoization of these requests is presented as an optimization.
     271As presented, this algorithm requires the result of the expression to have a known type, though an algorithm based on Cormack's could reasonably request a candidate set of any return type, though such a set may be quite large.
     272
     273\subsubsection{Hybrid}
     274This proposal includes the investigation of hybrid top-down/bottom-up argument-parameter matching.
     275A reasonable hybrid approach might be to take a top-down approach when the expression to be matched is known to have a fixed type, and a bottom-up approach in untyped contexts.
     276This may include switches from one type to another at different levels of the expression tree, for instance:
     277\begin{lstlisting}
     278forall(otype T)
     279int f(T x);  // (1)
     280
     281void* f(char y);  // (2)
     282
     283int x = f( f( '!' ) );
     284\end{lstlisting}
     285Here, the outer call to ©f© must have a return type that is (implicitly convertable to) ©int©, so a top-down approach could be used to select \textit{(1)} as the proper interpretation of ©f©. \textit{(1)}'s parameter ©x© here, however, is an unbound type variable, and can thus take a value of any complete type, providing no guidance for the choice of candidate for the inner ©f©. The leaf expression ©'!'©, however, gives us a zero-cost interpretation of the inner ©f© as \textit{(2)}, providing a minimal-cost expression resolution where ©T© is bound to ©void*©.
     286
     287Deciding when to switch between bottom-up and top-down resolution in a hybrid algorithm is a necessarily heuristic process, and though finding good heuristics for it is an open question, one reasonable approach might be to switch from top-down to bottom-up when the number of candidate functions exceeds some threshold.
     288
     289\subsection{Implicit Conversion Application}
     290Baker's\cite{Baker82} and Cormack's\cite{Cormack81} algorithms do not account for implicit conversions\footnote{Baker does briefly comment on an approach for handling implicit conversions.}; both assume that there is at most one valid interpretation of a given expression for each distinct type.
     291Integrating implicit conversion handling into their algorithms provides some choice of implementation approach.
     292
     293\subsubsection{On Parameters}
     294Bilson\cite{Bilson03} did account for implicit conversions in his algorithm, but it is not clear his approach is optimal.
     295His algorithm integrates checking for valid implicit conversions into the argument-parameter matching step, essentially trading more expensive matching for a smaller number of argument interpretations.
     296This approach may result in the same subexpression being checked for a type match with the same type multiple times, though again memoization may mitigate this cost, and this approach will not generate implicit conversions that are not useful to match the containing function.
     297
     298\subsubsection{On Arguments}
     299Another approach would be to generate a set of possible implicit conversions for each set of interpretations of a given argument.
     300This would have the benefit of detecting ambiguous interpretations of arguments at the level of the argument rather than its containing call, would also never find more than one interpretation of the argument with a given type, and would re-use calculation of implicit conversions between function candidates.
     301On the other hand, this approach may unncessarily generate argument interpretations that will never match a parameter, wasting work.
     302
     303\subsection{Candidate Set Generation}
     304Cormack\cite{Cormack81}, Baker\cite{Baker82} \& Bilson\cite{Bilson03} all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression.
     305However, given that the top-level expression interpretation that is ultimately chosen will be the minimal-cost valid interpretation, any consideration of non-minimal-cost interpretations is in some sense wasted work.
     306If we assume that user programmers will generally write function calls with relatively low-cost interpretations, a possible work-saving heuristic is to generate only the lowest-cost argument interpretations first, attempt to find a valid top-level interpretation using them, and only if that fails generate the higher-cost argument interpretations.
     307
     308\subsubsection{Eager}
     309Within the eager approach taken by Cormack, Baker \& Bilson, there are still variants to explore.
     310Cormack \& Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations.
     311Sorting the lists of argument or function call interpretations by cost at some point during resolution may provide useful opportunities to short-circuit expression evaluation when a minimal-cost interpretation is found, though it is not clear if this short-circuiting behaviour would justify the cost of the sort.
     312
     313\subsubsection{Lazy}
     314In the presence of implicit conversions, many argument interpretations may match a given parameter by application of an appropriate implicit conversion.
     315However, if user programmers actually use relatively few implicit conversions, then the ``on arguments'' approach to implicit conversions will generate a large number of high-cost interpretations which may never be used.
     316The essence of the lazy approach to candidate set generation is to wrap the matching algorithm into the element generator of a lazy list type, only generating as few elements at a time as possible to ensure that the next-smallest-cost interpretation has been generated.
     317Assuming that argument interpretations are provided to the parameter matching algorithm in sorted order, a sorted list of function call interpretations can be produced by generating combinations of arguments sorted by total cost\footnote{The author has developed a lazy $n$-way combination generation algorithm that can perform this task.}, then generating function call interpretations in the order suggested by this list.
     318Note that the function call interpretation chosen may have costs of its own, for instance polymorphic type binding, so in some cases a number of argument combinations (any combination whose marginal cost does not exceed the cost of the function call interpretation itself) may need to be considered to determine the next-smallest-cost function call interpretation.
     319Ideally, this candidate generation approach will lead to very few unused candidates being generated (in the expected case where the user programmer has, in fact, provided a validly-typable program), but this research project will need to determine whether or not the overheads of lazy generation exceed the benefit produced from considering fewer interpretations.
     320
     321\subsubsection{Stepwise Lazy}
     322As a compromise between the trade-offs of the eager and lazy approaches, it would also be interesting to investigate a ``stepwise lazy'' approach, where all the interpretations for some ``step'' are eagerly generated, then the interpretations in the later steps are only generated on demand.
     323Under this approach the \CFA resolver could, for instance, try expression interpretations in the following order:
     324\begin{enumerate}
     325\item Interpretations with no polymorphic type binding or implicit conversions.
     326\item Interpretations containing no polymorphic type binding and at least one safe implicit conversion.
     327\item Interpretations containing polymorphic type binding, but only safe implicit conversions.
     328\item Interpretations containing at least one unsafe implicit conversion.
     329\end{enumerate}
     330If a valid expression interpretation is found in one step, it is guaranteed to be lower-cost than any interpretation in a later step (by the structure of \CFA interpretation costs), so no step after the first one where a valid interpretation can be found need be considered.
     331This may save significant amounts of work, especially given that the first steps avoid potentially expensive handling of implicit conversions and type assertion satisfaction entirely.
     332
     333%\subsection{Parameter-Directed}
     334%\textbf{TODO: Richard's algorithm isn't Baker (Cormack?), disentangle from this section \ldots}.
     335%The expression resolution algorithm used by the existing iteration of {CFA-CC} is based on Baker's\cite{Baker82} algorithm for overload resolution in Ada.
     336%The essential idea of this algorithm is to first find the possible interpretations of the most deeply nested subexpressions, then to use these interpretations to recursively generate valid interpretations of their superexpressions.
     337%To simplify matters, the only expressions considered in this discussion of the algorithm are function application and literal expressions; other expression types can generally be considered to be variants of one of these for the purposes of the resolver, \eg variables are essentially zero-argument functions.
     338%If we consider expressions as graph nodes with arcs connecting them to their subexpressions, these expressions form a DAG, generated by the algorithm from the bottom up.
     339%Literal expressions are represented by leaf nodes, annotated with the type of the expression, while a function application will have a reference to the function declaration chosen, as well as arcs to the interpretation nodes for its argument expressions; functions are annotated with their return type (or types, in the case of multiple return values).
     340%
     341%\textbf{TODO: Figure}
     342%
     343%Baker's algorithm was designed to account for name overloading; Richard Bilson\cite{Bilson03} extended this algorithm to also handle polymorphic functions, implicit conversions \& multiple return types when designing the original \CFA compiler.
     344%The core of the algorithm is a function which Baker refers to as $gen\_calls$.
     345%$gen\_calls$ takes as arguments the name of a function $f$ and a list containing the set of possible subexpression interpretations $S_j$ for each argument of the function and returns a set of possible interpretations of calling that function on those arguments.
     346%The subexpression interpretations are generally either singleton sets generated by the single valid interpretation of a literal expression, or the results of a previous call to $gen\_calls$.
     347%If there are no valid interpretations of an expression, the set returned by $gen\_calls$ will be empty, at which point resolution can cease, since each subexpression must have at least one valid interpretation to produce an interpretation of the whole expression.
     348%On the other hand, if for some type $T$ there is more than one valid interpretation of an expression with type $T$, all interpretations of that expression with type $T$ can be collapsed into a single \emph{ambiguous expression} of type $T$, since the only way to disambiguate expressions is by their return types.
     349%If a subexpression interpretation is ambiguous, than any expression interpretation containing it will also be ambiguous.
     350%In the variant of this algorithm including implicit conversions, the interpretation of an expression as type $T$ is ambiguous only if there is more than one \emph{minimal-cost} interpretation of the expression as type $T$, as cheaper expressions are always chosen in preference to more expensive ones.
     351%
     352%Given this description of the behaviour of $gen\_calls$, its implementation is quite straightforward: for each function declaration $f_i$ matching the name of the function, consider each of the parameter types $p_j$ of $f_i$, attempting to match the type of an element of $S_j$ to $p_j$ (this may include checking of implicit conversions).
     353%If no such element can be found, there is no valid interpretation of the expression using $f_i$, while if more than one such (minimal-cost) element is found than an ambiguous interpretation with the result type of $f_i$ is produced.
     354%In the \CFA variant, which includes polymorphic functions, it is possible that a single polymorphic function definition $f_i$ can produce multiple valid interpretations by different choices of type variable bindings; these interpretations are unambiguous so long as the return type of $f_i$ is different for each type binding.
     355%If all the parameters $p_j$ of $f_i$ can be uniquely matched to a candidate interpretation, then a valid interpretation based on $f_i$ and those $p_j$ is produced.
     356%$gen\_calls$ collects the produced interpretations for each $f_i$ and returns them; a top level expression is invalid if this list is empty, ambiguous if there is more than one (minimal-cost) result, or if this single result is ambiguous, and valid otherwise.
     357%
     358%In this implementation, resolution of a single top-level expression takes time $O(\ldots)$, where \ldots. \textbf{TODO:} \textit{Look at 2.3.1 in Richard's thesis when working out complexity; I think he does get the Baker algorithm wrong on combinations though, maybe\ldots}
     359%
     360%\textbf{TODO: Basic Lit Review} \textit{Look at 2.4 in Richard's thesis for any possible more-recent citations of Baker\ldots} \textit{Look back at Baker's related work for other papers that look similar to what you're doing, then check their citations as well\ldots} \textit{Look at Richard's citations in 2.3.2 w.r.t. type data structures\ldots}
     361%\textit{CormackWright90 seems to describe a solution for the same problem, mostly focused on how to find the implicit parameters}
     362
     363\section{Proposal}
     364Baker\cite{Baker82} discussed various expression resolution algorithms that could handle name overloading, but left experimental comparison of those algorithms to future work; Bilson\cite{Bilson03} described one extension of Baker's algorithm to handle implicit conversions, but did not fully explore the space of algorithmic approaches to handle both overloaded names and implicit conversions.
     365This project is intended to experimentally test a number of expression resolution algorithms which are powerful enough to handle the \CFA type system, including both name overloading and implicit conversions.
     366This comparison will close Baker's open research question, as well as potentially improving on Bilson's \CFA compiler.
     367
     368Rather than testing all of these algorithms in-place in the \CFA compiler, a resolver prototype will be developed which acts on a simplified input language encapsulating the essential details of the \CFA type system\footnote{Note that this simplified input language is not required to be a usable programming language.}.
     369Multiple variants of this resolver prototype will be implemented, each encapsulating a different expression resolution variant, sharing as much code as feasible.
     370These variants will be instrumented to test runtime performance, and run on a variety of input files; the input files may be generated programmatically or from exisiting code in \CFA or similar languages.
     371These experimental results will allow the research team to determine the algorithm likely to be most performant in practical use, and replace {CFA-CC}'s existing expression resolver with that code.
     372The experimental results will also provide some empirical sense of the compile-time cost of various language features by comparing the results of the most performant resolver variant that supports the feature with the most performant resolver variant that doesn't, a useful capability to guide language design.
     373
     374This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type systems, specifically targeting the feature interaction between name overloading and implicit conversions.
     375
     376\appendix
    249377\section{Completion Timeline}
    250378The following is a preliminary estimate of the time necessary to complete the major components of this research project:
     
    252380\begin{tabular}{ | r @{--} l | p{4in} | }
    253381\hline       May 2015 & April 2016   & Project familiarization and generic types design \& implementation. \\
    254 \hline       May 2016 & April 2017   & Design \& implement prototype resolver and run performance experiments. \\
     382\hline       May 2016 & April 2017   & Design \& implement resolver prototype and run performance experiments. \\
    255383\hline       May 2017 & August 2017  & Integrate new language features and best-performing resolver prototype into {CFA-CC}. \\
    256384\hline September 2017 & January 2018 & Thesis writing \& defense. \\
     
    259387\end{center}
    260388
    261 \section{Conclusion}
    262 
    263 \newpage
    264 
     389\addcontentsline{toc}{section}{\refname}
    265390\bibliographystyle{plain}
    266391\bibliography{cfa}
    267392
    268 
    269 \addcontentsline{toc}{section}{\indexname} % add index name to table of contents
    270 \begin{theindex}
    271 Italic page numbers give the location of the main entry for the referenced term.
    272 Plain page numbers denote uses of the indexed term.
    273 Entries for grammar non-terminals are italicized.
    274 A typewriter font is used for grammar terminals and program identifiers.
    275 \indexspace
    276 \input{comp_II.ind}
    277 \end{theindex}
     393%\addcontentsline{toc}{section}{\indexname} % add index name to table of contents
     394%\begin{theindex}
     395%Italic page numbers give the location of the main entry for the referenced term.
     396%Plain page numbers denote uses of the indexed term.
     397%Entries for grammar non-terminals are italicized.
     398%A typewriter font is used for grammar terminals and program identifiers.
     399%\indexspace
     400%\input{comp_II.ind}
     401%\end{theindex}
    278402
    279403\end{document}
  • doc/bibliography/cfa.bib

    re4957e7 rbecba789  
    16231623    year        = 1974,
    16241624}
     1625
     1626@unpublished{Ditchfield:conversions,
     1627        contributer = {a3moss@uwaterloo.ca},
     1628        author = {Glen Ditchfield},
     1629        title = {Conversions for {Cforall}},
     1630        note = {\href{http://plg.uwaterloo.ca/~cforall/Conversions/index.html}{http://\-plg.uwaterloo.ca/\-\textasciitilde cforall/\-Conversions/\-index.html}},
     1631        month = {Nov},
     1632        year = {2002},
     1633        urldate = {28 July 2016},
     1634}
     1635
    16251636
    16261637@techreport{Dijkstra65,
  • doc/user/user.tex

    re4957e7 rbecba789  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Wed Jul 13 08:14:39 2016
    14 %% Update Count     : 1247
     13%% Last Modified On : Mon Aug  1 09:11:24 2016
     14%% Update Count     : 1271
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    211211however, it largely extended the language, and did not address many existing problems.\footnote{%
    212212Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.}
    213 \Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (e.g., objects, concurrency) are added and problems fixed within the framework of the existing language.
     213\Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
    214214\Index*{Java}~\cite{Java8}, \Index*{Go}~\cite{Go}, \Index*{Rust}~\cite{Rust} and \Index*{D}~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent.
    215215These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection.
     
    265265\section[Compiling CFA Program]{Compiling \CFA Program}
    266266
    267 The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, e.g.:
     267The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, \eg:
    268268\begin{lstlisting}
    269269cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ]
     
    350350\section{Underscores in Constants}
    351351
    352 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.:
     352Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, \eg:
    353353\begin{lstlisting}
    3543542®_®147®_®483®_®648;                    §\C{// decimal constant}§
     
    366366\begin{enumerate}
    367367\item
    368 A sequence of underscores is disallowed, e.g., ©12__34© is invalid.
     368A sequence of underscores is disallowed, \eg ©12__34© is invalid.
    369369\item
    370370Underscores may only appear within a sequence of digits (regardless of the digit radix).
    371 In other words, an underscore cannot start or end a sequence of digits, e.g., ©_1©, ©1_© and ©_1_© are invalid (actually, the 1st and 3rd examples are identifier names).
     371In other words, an underscore cannot start or end a sequence of digits, \eg ©_1©, ©1_© and ©_1_© are invalid (actually, the 1st and 3rd examples are identifier names).
    372372\item
    373373A numeric prefix may end with an underscore;
     
    498498\end{quote2}
    499499
    500 All type qualifiers, e.g., ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, e.g.:
     500All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
    501501\begin{quote2}
    502502\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
     
    518518\end{tabular}
    519519\end{quote2}
    520 All declaration qualifiers, e.g., ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
    521 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} e.g.:
     520All declaration qualifiers, \eg ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
     521The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} \eg:
    522522\begin{quote2}
    523523\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     
    542542Unsupported are K\&R C declarations where the base type defaults to ©int©, if no type is specified,\footnote{
    543543At least one type specifier shall be given in the declaration specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and type name~\cite[\S~6.7.2(2)]{C11}}
    544 e.g.:
     544\eg:
    545545\begin{lstlisting}
    546546x;                                                              §\C{// int x}§
     
    612612A \Index{pointer}/\Index{reference} is a generalization of a variable name, i.e., a mutable address that can point to more than one memory location during its lifetime.
    613613(Similarly, an integer variable can contain multiple integer literals during its lifetime versus an integer constant representing a single literal during its lifetime and may not occupy storage as the literal is embedded directly into instructions.)
    614 Hence, a pointer occupies memory to store its current address, and the pointer's value is loaded by dereferencing, e.g.:
     614Hence, a pointer occupies memory to store its current address, and the pointer's value is loaded by dereferencing, \eg:
    615615\begin{quote2}
    616616\begin{tabular}{@{}ll@{}}
     
    669669Except for auto-dereferencing by the compiler, this reference example is the same as the previous pointer example.
    670670Hence, a reference behaves like the variable name for the current variable it is pointing-to.
    671 The simplest way to understand a reference is to imagine the compiler inserting a dereference operator before the reference variable for each reference qualifier in a declaration, e.g.:
     671The simplest way to understand a reference is to imagine the compiler inserting a dereference operator before the reference variable for each reference qualifier in a declaration, \eg:
    672672\begin{lstlisting}
    673673r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15);
     
    677677®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
    678678\end{lstlisting}
    679 When a reference operation appears beside a dereference operation, e.g., ©&*©, they cancel out.\footnote{
     679When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.\footnote{
    680680The unary ©&© operator yields the address of its operand.
    681681If the operand has type ``type'', the result has type ``pointer to type''.
     
    721721®&®crc = &cx;                                   §\C{// error, cannot change crc}§
    722722\end{lstlisting}
    723 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be ©0© unless an arbitrary pointer is assigned to the reference}, e.g.:
     723Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be ©0© unless an arbitrary pointer is assigned to the reference}, \eg:
    724724\begin{lstlisting}
    725725int & const r = *0;                             §\C{// where 0 is the int * zero}§
    726726\end{lstlisting}
    727727Otherwise, the compiler is managing the addresses for type ©& const© not the programmer, and by a programming discipline of only using references with references, address errors can be prevented.
     728Finally, the position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers.
     729The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations;
     730\CFA-style declarations attempt to address this issue:
     731\begin{quote2}
     732\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     733\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     734\begin{lstlisting}
     735®const® * ®const® * const int ccp;
     736®const® & ®const® & const int ccr;
     737\end{lstlisting}
     738&
     739\begin{lstlisting}
     740const int * ®const® * ®const® ccp;
     741
     742\end{lstlisting}
     743\end{tabular}
     744\end{quote2}
     745where the \CFA declaration is read left-to-right (see \VRef{s:Declarations}).
    728746
    729747\Index{Initialization} is different than \Index{assignment} because initialization occurs on the empty (uninitialized) storage on an object, while assignment occurs on possibly initialized storage of an object.
     
    785803\section{Type Operators}
    786804
    787 The new declaration syntax can be used in other contexts where types are required, e.g., casts and the pseudo-routine ©sizeof©:
     805The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine ©sizeof©:
    788806\begin{quote2}
    789807\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     
    805823
    806824\CFA also supports a new syntax for routine definition, as well as ISO C and K\&R routine syntax.
    807 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, e.g.:
     825The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
    808826\begin{lstlisting}
    809827®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
     
    817835\Index*{Michael Tiemann}, with help from \Index*{Doug Lea}, provided named return values in g++, circa 1989.}
    818836The value of each local return variable is automatically returned at routine termination.
    819 Declaration qualifiers can only appear at the start of a routine definition, e.g.:
     837Declaration qualifiers can only appear at the start of a routine definition, \eg:
    820838\begin{lstlisting}
    821839®extern® [ int x ] g( int y ) {§\,§}
     
    849867The inability to use \CFA declarations in these two contexts is probably a blessing because it precludes programmers from arbitrarily switching between declarations forms within a declaration contexts.
    850868
    851 C-style declarations can be used to declare parameters for \CFA style routine definitions, e.g.:
     869C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
    852870\begin{lstlisting}
    853871[ int ] f( * int, int * );              §\C{// returns an integer, accepts 2 pointers to integers}§
     
    898916
    899917The syntax of the new routine prototype declaration follows directly from the new routine definition syntax;
    900 as well, parameter names are optional, e.g.:
     918as well, parameter names are optional, \eg:
    901919\begin{lstlisting}
    902920[ int x ] f ();                                 §\C{// returning int with no parameters}§
     
    906924\end{lstlisting}
    907925This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
    908 It is possible to declare multiple routine-prototypes in a single declaration, but the entire type specification is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), e.g.:
     926It is possible to declare multiple routine-prototypes in a single declaration, but the entire type specification is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), \eg:
    909927\begin{quote2}
    910928\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     
    919937\end{tabular}
    920938\end{quote2}
    921 Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} e.g.:
     939Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} \eg:
    922940\begin{lstlisting}
    923941extern [ int ] f (int);
     
    928946\section{Routine Pointers}
    929947
    930 The syntax for pointers to \CFA routines specifies the pointer name on the right, e.g.:
     948The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
    931949\begin{lstlisting}
    932950* [ int x ] () fp;                      §\C{// pointer to routine returning int with no parameters}§
     
    10461064p( /* positional */, /* named */, . . . );
    10471065\end{lstlisting}
    1048 While it is possible to implement both approaches, the first possibly is more complex than the second, e.g.:
     1066While it is possible to implement both approaches, the first possibly is more complex than the second, \eg:
    10491067\begin{lstlisting}
    10501068p( int x, int y, int z, . . . );
     
    10561074In the second call, the named arguments separate the positional and ellipse arguments, making it trivial to read the call.
    10571075
    1058 The problem is exacerbated with default arguments, e.g.:
     1076The problem is exacerbated with default arguments, \eg:
    10591077\begin{lstlisting}
    10601078void p( int x, int y = 2, int z = 3. . . );
     
    12641282
    12651283As mentioned, tuples can appear in contexts requiring a list of value, such as an argument list of a routine call.
    1266 In unambiguous situations, the tuple brackets may be omitted, e.g., a tuple that appears as an argument may have its
     1284In unambiguous situations, the tuple brackets may be omitted, \eg a tuple that appears as an argument may have its
    12671285square brackets omitted for convenience; therefore, the following routine invocations are equivalent:
    12681286\begin{lstlisting}
     
    13031321
    13041322Type qualifiers, i.e., const and volatile, may modify a tuple type.
    1305 The meaning is the same as for a type qualifier modifying an aggregate type [Int99, x 6.5.2.3(7),x 6.7.3(11)], i.e., the qualifier is distributed across all of the types in the tuple, e.g.:
     1323The meaning is the same as for a type qualifier modifying an aggregate type [Int99, x 6.5.2.3(7),x 6.7.3(11)], i.e., the qualifier is distributed across all of the types in the tuple, \eg:
    13061324\begin{lstlisting}
    13071325const volatile [ int, float, const int ] x;
     
    13111329[ const volatile int, const volatile float, const volatile int ] x;
    13121330\end{lstlisting}
    1313 Declaration qualifiers can only appear at the start of a \CFA tuple declaration4, e.g.:
     1331Declaration qualifiers can only appear at the start of a \CFA tuple declaration4, \eg:
    13141332\begin{lstlisting}
    13151333extern [ int, int ] w1;
     
    13191337Unfortunately, C's syntax for subscripts precluded treating them as tuples.
    13201338The C subscript list has the form ©[i][j]...© and not ©[i, j, ...]©.
    1321 Therefore, there is no syntactic way for a routine returning multiple values to specify the different subscript values, e.g., ©f[g()]© always means a single subscript value because there is only one set of brackets.
     1339Therefore, there is no syntactic way for a routine returning multiple values to specify the different subscript values, \eg ©f[g()]© always means a single subscript value because there is only one set of brackets.
    13221340Fixing this requires a major change to C because the syntactic form ©M[i, j, k]© already has a particular meaning: ©i, j, k© is a comma expression.
    13231341\end{rationale}
     
    13801398Clearly, the types of the entities being assigned must be type compatible with the value of the expression.
    13811399
    1382 Mass assignment has parallel semantics, e.g., the statement:
     1400Mass assignment has parallel semantics, \eg the statement:
    13831401\begin{lstlisting}
    13841402[ x, y, z ] = 1.5;
     
    14691487\section{Unnamed Structure Fields}
    14701488
    1471 C requires each field of a structure to have a name, except for a bit field associated with a basic type, e.g.:
     1489C requires each field of a structure to have a name, except for a bit field associated with a basic type, \eg:
    14721490\begin{lstlisting}
    14731491struct {
    1474         int f1;                 // named field
    1475         int f2 : 4;             // named field with bit field size
    1476         int : 3;                // unnamed field for basic type with bit field size
    1477         int ;                   // disallowed, unnamed field
    1478         int *;                  // disallowed, unnamed field
    1479         int (*)(int);   // disallowed, unnamed field
     1492        int f1;                                 §\C{// named field}§
     1493        int f2 : 4;                             §\C{// named field with bit field size}§
     1494        int : 3;                                §\C{// unnamed field for basic type with bit field size}§
     1495        int ;                                   §\C{// disallowed, unnamed field}§
     1496        int *;                                  §\C{// disallowed, unnamed field}§
     1497        int (*)(int);                   §\C{// disallowed, unnamed field}§
    14801498};
    14811499\end{lstlisting}
    14821500This requirement is relaxed by making the field name optional for all field declarations; therefore, all the field declarations in the example are allowed.
    14831501As for unnamed bit fields, an unnamed field is used for padding a structure to a particular size.
    1484 A list of unnamed fields is also supported, e.g.:
     1502A list of unnamed fields is also supported, \eg:
    14851503\begin{lstlisting}
    14861504struct {
    1487         int , , ;               // 3 unnamed fields
     1505        int , , ;                               §\C{// 3 unnamed fields}§
    14881506}
    14891507\end{lstlisting}
     
    14981516§\emph{expr}§ -> [ §\emph{fieldlist}§ ]
    14991517\end{lstlisting}
    1500 \emph{expr} is any expression yielding a value of type record, e.g., ©struct©, ©union©.
     1518\emph{expr} is any expression yielding a value of type record, \eg ©struct©, ©union©.
    15011519Each element of \emph{ fieldlist} is an element of the record specified by \emph{expr}.
    15021520A record-field tuple may be used anywhere a tuple can be used. An example of the use of a record-field tuple is
     
    17601778}
    17611779\end{lstlisting}
    1762 While the declaration of the local variable ©y© is useful and its scope is across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
    1763 Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©.
    1764 As mentioned, transfer into control structures should be forbidden;
    1765 transfers from within the ©switch© body using a ©goto© are equally unpalatable.
    1766 As well, the declaration of ©z© is cannot occur after the ©case© because a label can only be attached to a statement, and without a fall through to case 3, ©z© is uninitialized.
     1780While the declaration of the local variable ©y© is useful with a scope across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
     1781Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, both of which are problematic.
     1782As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fall through to case 3, ©z© is uninitialized.
     1783The key observation is that the ©switch© statement branches into control structure, i.e., there are multiple entry points into its statement body.
    17671784\end{enumerate}
    17681785
     
    17781795and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
    17791796\end{itemize}
    1780 These observations help to put the suggested changes to the ©switch© into perspective.
     1797These observations help to put the \CFA changes to the ©switch© into perspective.
    17811798\begin{enumerate}
    17821799\item
    17831800Eliminating default fall-through has the greatest potential for affecting existing code.
    1784 However, even if fall-through is removed, most ©switch© statements would continue to work because of the explicit transfers already present at the end of each ©case© clause, the common placement of the ©default© clause at the end of the case list, and the most common use of fall-through, i.e., a list of ©case© clauses executing common code, e.g.:
    1785 \begin{lstlisting}
     1801However, even if fall-through is removed, most ©switch© statements would continue to work because of the explicit transfers already present at the end of each ©case© clause, the common placement of the ©default© clause at the end of the case list, and the most common use of fall-through, i.e., a list of ©case© clauses executing common code, \eg:
     1802 \begin{lstlisting}
    17861803case 1:  case 2:  case 3: ...
    17871804\end{lstlisting}
    17881805still work.
    17891806Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
    1790 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©, e.g.:
     1807<<<<<<< HEAD
     1808Therefore, 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:
     1809=======
     1810Therefore, 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.:
     1811>>>>>>> 080615890f586cb9954c252b55cab47f52c25758
    17911812\begin{lstlisting}
    17921813®choose® ( i ) {
     
    18151836Therefore, no change is made for this issue.
    18161837\item
    1817 Dealing with unreachable code in a ©switch©/©choose© body is solved by restricting declarations and associated initialization to the start of statement body, which is executed \emph{before} the transfer to the appropriate ©case© clause.\footnote{
    1818 Essentially, these declarations are hoisted before the statement and both declarations and statement are surrounded by a compound statement.} and precluding statements before the first ©case© clause.
    1819 Further declaration in the statement body are disallowed.
     1838Dealing with unreachable code in a ©switch©/©choose© body is solved by restricting declarations and associated initialization to the start of statement body, which is executed \emph{before} the transfer to the appropriate ©case© clause\footnote{
     1839Essentially, these declarations are hoisted before the ©switch©/©choose© statement and both declarations and statement are surrounded by a compound statement.} and precluding statements before the first ©case© clause.
     1840Further declarations at the same nesting level as the statement body are disallowed to ensure every transfer into the body is sound.
    18201841\begin{lstlisting}
    18211842switch ( x ) {
    1822         ®int i = 0;®                            §\C{// allowed
     1843        ®int i = 0;®                            §\C{// allowed only at start
    18231844  case 0:
    18241845        ...
    1825         ®int i = 0;®                            §\C{// disallowed}§
     1846        ®int j = 0;®                            §\C{// disallowed}§
    18261847  case 1:
    18271848    {
    1828                 ®int i = 0;®                    §\C{// allowed in any compound statement
     1849                ®int k = 0;®                    §\C{// allowed at different nesting levels
    18291850                ...
    18301851        }
     
    27072728Like the \Index*[C++]{\CC} lexical problem with closing template-syntax, e.g, ©Foo<Bar<int®>>®©, this issue can be solved with a more powerful lexer/parser.
    27082729
    2709 There are several ambiguous cases with operator identifiers, e.g., ©int *?*?()©, where the string ©*?*?© can be lexed as ©*©/©?*?© or ©*?©/©*?©.
    2710 Since it is common practise to put a unary operator juxtaposed to an identifier, e.g., ©*i©, users will be annoyed if they cannot do this with respect to operator identifiers.
     2730There are several ambiguous cases with operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be lexed as ©*©/©?*?© or ©*?©/©*?©.
     2731Since it is common practise to put a unary operator juxtaposed to an identifier, \eg ©*i©, users will be annoyed if they cannot do this with respect to operator identifiers.
    27112732Even with this special hack, there are 5 general cases that cannot be handled.
    27122733The first case is for the function-call identifier ©?()©:
     
    27732794This means that a function requiring mutual exclusion could block if the lock is already held by another thread.
    27742795Blocking on a monitor lock does not block the kernel thread, it simply blocks the user thread, which yields its kernel thread while waiting to obtain the lock.
    2775 If multiple mutex parameters are specified, they will be locked in parameter order (i.e. first parameter is locked first) and unlocked in the
     2796If multiple mutex parameters are specified, they will be locked in parameter order (\ie first parameter is locked first) and unlocked in the
    27762797reverse order.
    27772798\begin{lstlisting}
     
    43424363
    43434364
     4365\section{New Keywowrds}
     4366
     4367©catch©, ©catchResume©, ©choose©, \quad ©disable©, ©dtype©, \quad ©enable©, \quad ©fallthrough©, ©fallthru©, ©finally©, ©forall©, ©ftype©, \quad ©lvalue©, \quad ©otype©, \quad ©throw©, ©throwResume©, ©trait©, ©try©
     4368
     4369
    43444370\section{Incompatible}
    43454371
     
    44714497\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \Index*[C++]{\CC}.
    44724498Nested types are not hoisted and can be referenced using the field selection operator ``©.©'', unlike the \CC scope-resolution operator ``©::©''.
    4473 Given that nested types in C are equivalent to not using them, i.e., they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility.
     4499Given that nested types in C are equivalent to not using them, \ie they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility.
    44744500\end{description}
    44754501
     
    51625188\label{s:RationalNumbers}
    51635189
    5164 Rational numbers are numbers written as a ratio, i.e., as a fraction, where the numerator (top number) and the denominator (bottom number) are whole numbers.
     5190Rational numbers are numbers written as a ratio, \ie as a fraction, where the numerator (top number) and the denominator (bottom number) are whole numbers.
    51655191When creating and computing with rational numbers, results are constantly reduced to keep the numerator and denominator as small as possible.
    51665192
  • src/CodeGen/CodeGenerator.cc

    re4957e7 rbecba789  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 15 15:53:15 2016
    13 // Update Count     : 306
     11// Last Modified By :
     12// Last Modified On : Sun Jul 31 08:42:18 2016
     13// Update Count     : 345
    1414//
    1515
     
    4545        bool wantSpacing( Statement * stmt) {
    4646                return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
    47                         dynamic_cast< WhileStmt * >( stmt ) || dynamic_cast< ForStmt * > ( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
     47                        dynamic_cast< WhileStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
    4848        }
    4949
     
    8383        }
    8484
    85         CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ) { }
     85        CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ) {}
    8686
    8787        CodeGenerator::CodeGenerator( std::ostream &os, std::string init, int indentation, bool infunp )
     
    155155                        objectDecl->get_init()->accept( *this );
    156156                } // if
     157
    157158                if ( objectDecl->get_bitfieldWidth() ) {
    158159                        output << ":";
     
    172173
    173174                        cur_indent += CodeGenerator::tabsize;
    174                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
     175                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
    175176                                output << indent;
    176177                                (*i)->accept( *this );
    177178                                output << ";" << endl;
    178                         }
     179                        } // for
    179180
    180181                        cur_indent -= CodeGenerator::tabsize;
     
    257258                                (*iter)->accept( *this );
    258259                                output << "]";
    259                         }
    260                 }
     260                        } // if
     261                } // for
    261262                output << " = ";
    262263        }
     
    317318                                        // do nothing
    318319                                        ;
    319                                 }
     320                                } // switch
    320321
    321322                                switch ( opInfo.type ) {
     
    385386                                        // there are no intrinsic definitions of 0/1 or label addresses as functions
    386387                                        assert( false );
    387                                 }
     388                                } // switch
    388389                        } else {
    389390                                varExpr->accept( *this );
     
    417418                                  case OT_CALL:
    418419                                        assert( false );
    419 
    420420
    421421                                  case OT_CTOR:
     
    437437                                                // no constructors with 0 or more than 2 parameters
    438438                                                assert( false );
    439                                         }
     439                                        } // if
    440440                                        break;
    441441
     
    470470                                        // there are no intrinsic definitions of 0 or 1 as functions
    471471                                        assert( false );
    472                                 }
     472                                } // switch
    473473                        } else {
    474                                 nameExpr->accept( *this );
    475                                 output << "(";
    476                                 genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
    477                                 output << ")";
     474                                if ( nameExpr->get_name() == "Range" ) { // case V1 ... V2 or case V1~V2
     475                                        assert( untypedExpr->get_args().size() == 2 );
     476                                        (*untypedExpr->get_args().begin())->accept( *this );
     477                                        output << " ... ";
     478                                        (*--untypedExpr->get_args().end())->accept( *this );
     479                                } else {                                                                // builtin routines
     480                                        nameExpr->accept( *this );
     481                                        output << "(";
     482                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
     483                                        output << ")";
     484                                } // if
    478485                        } // if
    479486                } else {
     
    521528                        // otherwise, the cast is to an lvalue type, so the cast should be dropped, since the result of a cast is
    522529                        // never an lvalue in C
    523                 }
     530                } // if
    524531                castExpr->get_arg()->accept( *this );
    525532                output << ")";
     
    654661                        if ( wantSpacing( *i ) ) {
    655662                                output << endl;
    656                         }
     663                        } // if
    657664                }
    658665                cur_indent -= CodeGenerator::tabsize;
     
    737744                        (*i)->accept( *this );
    738745                        output << endl;
    739                 }
     746                } // for
    740747                cur_indent -= CodeGenerator::tabsize;
    741748        }
     
    759766                        output << "continue";
    760767                        break;
    761                 }
     768                } // switch
    762769                output << ";";
    763770        }
     
    798805                if ( forStmt->get_condition() != 0 ) {
    799806                        forStmt->get_condition()->accept( *this );
    800                 }
     807                } // if
    801808                output << ";";
    802809
     
    805812                        Expression * expr = new CastExpr( forStmt->get_increment() );
    806813                        expr->accept( *this );
    807                 }
     814                } // if
    808815                output << ") ";
    809816
  • src/CodeGen/CodeGenerator.h

    re4957e7 rbecba789  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul  4 17:12:40 2016
    13 // Update Count     : 34
     12// Last Modified On : Sat Jul 30 11:10:42 2016
     13// Update Count     : 37
    1414//
    1515
     
    118118                void handleAggregate( AggregateDecl *aggDecl );
    119119                void handleTypedef( NamedTypeDecl *namedType );
    120         };
     120        }; // CodeGenerator
    121121
    122122        template< class Iterator >
  • src/ControlStruct/CaseRangeMutator.cc

    re4957e7 rbecba789  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:35:13 2016
    13 // Update Count     : 9
     11// Last Modified By :
     12// Last Modified On : Sun Jul 31 12:16:28 2016
     13// Update Count     : 32
    1414//
    1515
     
    3434                std::list< Statement * >::iterator i = cases.begin();
    3535                while ( i != cases.end() ) {
    36                         (*i )->acceptMutator( *this );
     36                        (*i)->acceptMutator( *this );
    3737
    3838                        if ( ! newCaseLabels.empty() ) {
     39                                std::cout << "FRED" << std::endl;
    3940                                std::list< Statement * > newCases;
    4041
    4142                                // transform( newCaseLabels.begin(), newCaseLabels.end(), bnd1st( ptr_fun( ctor< CaseStmt, Label, Expression * > ) ) );
    4243
    43                                 for ( std::list< Expression * >::iterator j = newCaseLabels.begin();
    44                                           j != newCaseLabels.end(); j++ ) {
    45                                         std::list<Label> emptyLabels;
    46                                         std::list< Statement *> emptyStmts;
     44                                for ( std::list< Expression * >::iterator j = newCaseLabels.begin(); j != newCaseLabels.end(); j++ ) {
     45                                        std::list< Label > emptyLabels;
     46                                        std::list< Statement * > emptyStmts;
    4747                                        newCases.push_back( new CaseStmt( emptyLabels, *j, emptyStmts ) );
    4848                                } // for
    4949
    50                                 if ( CaseStmt *currentCase = dynamic_cast< CaseStmt * > ( *i ) )
     50                                if ( CaseStmt *currentCase = dynamic_cast< CaseStmt * >( *i ) )
    5151                                        if ( ! currentCase->get_statements().empty() ) {
    52                                                 CaseStmt *lastCase = dynamic_cast< CaseStmt * > ( newCases.back() );
     52                                                CaseStmt *lastCase = dynamic_cast< CaseStmt * >( newCases.back() );
    5353                                                if ( lastCase == 0 ) { throw ( 0 ); /* FIXME */ } // something is very wrong, as I just made these, and they were all cases
    5454                                                // transfer the statement block ( if any ) to the new list:
    5555                                                lastCase->set_statements( currentCase->get_statements() );
    5656                                        } // if
    57                                 std::list< Statement * >::iterator j = i; advance( j, 1 );
    58                                 replace ( cases, i, newCases );
     57                                std::list< Statement * >::iterator j = i;
     58                                advance( j, 1 );
     59                                replace( cases, i, newCases );
    5960                                i = j;
    6061                                newCaseLabels.clear();
     
    6465
    6566                return switchStmt;
    66         }
     67        } // CaseRangeMutator::mutate
    6768
    6869        Statement *CaseRangeMutator::mutate( CaseStmt *caseStmt ) {
    69                 UntypedExpr *cond;
    70                 if ( ( cond = dynamic_cast< UntypedExpr * >( caseStmt->get_condition() )) != 0 ) {
    71                         NameExpr *nmfunc;
    72                         if ( ( nmfunc = dynamic_cast< NameExpr *>( cond->get_function() )) != 0 ) {
    73                                 if ( nmfunc->get_name() == std::string("Range") ) {
    74                                         assert( cond->get_args().size() == 2 );
    75                                         std::list<Expression *>::iterator i = cond->get_args().begin();
    76                                         Expression *lo = *i, *hi = *(++i ); // "unnecessary" temporaries
    77                                         fillRange( lo, hi );
    78                                 } // if
    79                         } // if
    80                 } else if ( TupleExpr *tcond = dynamic_cast< TupleExpr * >( caseStmt->get_condition() ) ) {
    81                         // case list
     70                // case list, e.g., case 1, 3, 5:
     71                if ( TupleExpr *tcond = dynamic_cast< TupleExpr * >( caseStmt->get_condition() ) ) {
    8272                        assert( ! tcond->get_exprs().empty() );
    83                         for ( std::list< Expression * >::iterator i = tcond->get_exprs().begin(); i != tcond->get_exprs().end(); i++ )
    84                                 newCaseLabels.push_back( *i ); // do I need to clone them?
     73                        for ( std::list< Expression * >::iterator i = tcond->get_exprs().begin(); i != tcond->get_exprs().end(); i++ ) {
     74                                newCaseLabels.push_back( *i );                  // do I need to clone them?
     75                        } // for
    8576                } // if
    8677
    8778                std::list< Statement * > &stmts = caseStmt->get_statements();
    88                 mutateAll ( stmts, *this );
     79                mutateAll( stmts, *this );
    8980
    9081                return caseStmt;
    91         }
    92 
    93         void CaseRangeMutator::fillRange( Expression *lo, Expression *hi ) {
    94                 // generate the actual range ( and check for consistency )
    95                 Constant *c_lo, *c_hi;
    96                 ConstantExpr *ce_lo, *ce_hi;
    97                 ce_lo = dynamic_cast< ConstantExpr * >( lo );
    98                 ce_hi = dynamic_cast< ConstantExpr * >( hi );
    99 
    100                 if ( ce_lo && ce_hi ) {
    101                         c_lo = ce_lo->get_constant(); c_hi = ce_hi->get_constant();
    102                 } /* else {
    103                          if ( ! ce_lo ) ;
    104                          if ( ! ce_hi ) ;
    105                          } */
    106                 BasicType *ty_lo = dynamic_cast< BasicType * >( c_lo->get_type() ),
    107                         *ty_hi = dynamic_cast< BasicType * >( c_hi->get_type() );
    108        
    109                 if ( ! ty_lo || ! ty_hi )
    110                         return; // one of them is not a constant
    111 
    112                 switch ( ty_lo->get_kind() ) {
    113                   case BasicType::Char:
    114                   case BasicType::UnsignedChar:
    115                         switch ( ty_hi->get_kind() ) {
    116                           case BasicType::Char:
    117                           case BasicType::UnsignedChar:
    118                                 // first case, they are both printable ASCII characters represented as 'x'
    119                                 if ( c_lo->get_value().size() == 3 && c_hi->get_value().size() == 3 ) {
    120                                         char ch_lo = ( c_lo->get_value())[1], ch_hi = ( c_hi->get_value())[1];
    121 
    122                                         if ( ch_lo > ch_hi ) { char t=ch_lo; ch_lo=ch_hi; ch_hi=t; }
    123 
    124                                         for ( char c = ch_lo; c <=  ch_hi; c++ ) {
    125                                                 Type::Qualifiers q;
    126                                                 Constant cnst( new BasicType( q, BasicType::Char ),
    127                                                                            std::string("'") + c + std::string("'") );
    128                                                 newCaseLabels.push_back( new ConstantExpr( cnst ) );
    129                                         } // for
    130 
    131                                         return;
    132                                 } // if
    133                                 break;
    134                           default:
    135                                 // error: incompatible constants
    136                                 break;
    137                         } // switch
    138                         break;
    139                   case BasicType::ShortSignedInt:
    140                   case BasicType::ShortUnsignedInt:
    141                   case BasicType::SignedInt:
    142                   case BasicType::UnsignedInt:
    143                   case BasicType::LongSignedInt:
    144                   case BasicType::LongUnsignedInt:
    145                   case BasicType::LongLongSignedInt:
    146                   case BasicType::LongLongUnsignedInt:
    147                         switch ( ty_hi->get_kind() ) {
    148                           case BasicType::ShortSignedInt:
    149                           case BasicType::ShortUnsignedInt:
    150                           case BasicType::SignedInt:
    151                           case BasicType::UnsignedInt:
    152                           case BasicType::LongSignedInt:
    153                           case BasicType::LongUnsignedInt:
    154                           case BasicType::LongLongSignedInt:
    155                           case BasicType::LongLongUnsignedInt: {
    156                                   int i_lo = atoi( c_lo->get_value().c_str()),
    157                                           i_hi = atoi( c_hi->get_value().c_str());
    158 
    159                                   if ( i_lo > i_hi ) { int t=i_lo; i_lo=i_hi; i_hi=t; }
    160 
    161                                   for ( int c = i_lo; c <=  i_hi; c++ ) {
    162                                           Type::Qualifiers q;
    163                                           Constant cnst( new BasicType( q, ty_hi->get_kind()), // figure can't hurt (used to think in positives)
    164                                                                          toString< int >( c ) );
    165                                           newCaseLabels.push_back( new ConstantExpr( cnst ) );
    166                                   }
    167 
    168                                   return;
    169                           }
    170                           default:
    171                                 // error: incompatible constants
    172                                 break;
    173                         }
    174                         break;
    175                   default:
    176                         break;
    177                 } // switch
    178 
    179                 /* End: */{
    180                         // invalid range, signal a warning (it still generates the two case labels)
    181                         newCaseLabels.push_back( lo );
    182                         newCaseLabels.push_back( hi );
    183                         return;
    184                 }
    185         }
     82        } // CaseRangeMutator::mutate
    18683} // namespace ControlStruct
    18784
  • src/ControlStruct/CaseRangeMutator.h

    re4957e7 rbecba789  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:35:30 2016
    13 // Update Count     : 4
     12// Last Modified On : Sat Jul 30 23:41:57 2016
     13// Update Count     : 5
    1414//
    1515
     
    3030                virtual Statement *mutate( CaseStmt * );
    3131          private:
    32                 void fillRange( Expression *lo, Expression *hi );
    33 
    3432                Expression *currentCondition;
    3533                std::list< Expression * > newCaseLabels;
  • src/Parser/lex.cc

    re4957e7 rbecba789  
    382382        (yy_c_buf_p) = yy_cp;
    383383
    384 #define YY_NUM_RULES 180
    385 #define YY_END_OF_BUFFER 181
     384#define YY_NUM_RULES 181
     385#define YY_END_OF_BUFFER 182
    386386/* This struct is not used in this scanner,
    387387   but its presence is necessary. */
     
    391391        flex_int32_t yy_nxt;
    392392        };
    393 static yyconst flex_int16_t yy_accept[888] =
     393static yyconst flex_int16_t yy_accept[892] =
    394394    {   0,
    395         0,    0,    0,    0,    0,    0,  115,  115,  118,  118,
    396       181,  179,    7,    9,    8,  138,  117,  102,  143,  146,
    397       114,  125,  126,  141,  139,  129,  140,  132,  142,  107,
    398       108,  109,  130,  131,  148,  150,  149,  151,  179,  102,
    399       123,  179,  124,  144,  102,  104,  102,  102,  102,  102,
    400       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    401       102,  102,  127,  147,  128,  145,    7,  179,    4,    4,
    402       180,  105,  180,  106,  115,  116,  122,  118,  119,    7,
    403         9,    0,    8,  155,  174,  102,    0,  167,  137,  160,
    404       168,  165,  152,  163,  153,  164,  162,    0,  112,    3,
    405 
    406         0,  166,  112,  110,    0,    0,  110,  110,    0,    0,
    407       110,  109,  109,  109,    0,  109,  135,  136,  134,  156,
    408       158,  154,  159,  157,    0,    0,    0,    0,    0,    0,
    409         0,    0,    0,    0,    0,    0,    0,    0,    0,  103,
    410       173,    0,  117,  114,  102,    0,    0,  170,    0,  102,
    411       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    412       102,  102,  102,  102,  102,  102,   38,  102,  102,  102,
    413       102,  102,  102,  102,  102,  102,  102,   56,  102,  102,
    414       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    415       102,  102,  102,  102,  169,  161,    7,    0,    0,    0,
    416 
    417         2,    0,    5,  105,    0,    0,    0,  115,    0,  121,
    418       120,  120,    0,    0,    0,  118,    0,    0,    0,    0,
     395        0,    0,    0,    0,    0,    0,  116,  116,  119,  119,
     396      182,  180,    7,    9,    8,  139,  118,  103,  144,  147,
     397      115,  126,  127,  142,  140,  130,  141,  133,  143,  108,
     398      109,  110,  131,  132,  149,  151,  150,  152,  180,  103,
     399      124,  180,  125,  145,  103,  105,  103,  103,  103,  103,
     400      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     401      103,  103,  128,  148,  129,  146,    7,  180,    4,    4,
     402      181,  106,  181,  107,  116,  117,  123,  119,  120,    7,
     403        9,    0,    8,  156,  175,  103,    0,  168,  138,  161,
     404      169,  166,  153,  164,  154,  165,  163,    0,  113,    3,
     405
     406        0,  167,  113,  111,    0,    0,  111,  111,    0,    0,
     407      111,  110,  110,  110,    0,  110,  136,  137,  135,  157,
     408      159,  155,  160,  158,    0,    0,    0,    0,    0,    0,
     409        0,    0,    0,    0,    0,    0,    0,    0,    0,  104,
     410      174,    0,  118,  115,  103,    0,    0,  171,    0,  103,
     411      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     412      103,  103,  103,  103,  103,  103,   38,  103,  103,  103,
     413      103,  103,  103,  103,  103,  103,  103,   57,  103,  103,
     414      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     415      103,  103,  103,  103,  170,  162,    7,    0,    0,    0,
     416
     417        2,    0,    5,  106,    0,    0,    0,  116,    0,  122,
     418      121,  121,    0,    0,    0,  119,    0,    0,    0,    0,
    419419        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    420         0,  133,  112,  112,    0,  112,  112,    0,    0,    6,
    421         0,  110,    0,    0,    0,  112,    0,  110,  110,  110,
    422       110,    0,  111,    0,    0,  109,  109,  109,  109,    0,
    423       171,  172,    0,  177,  175,    0,    0,    0,  103,    0,
    424         0,    0,    0,    0,    0,    0,    0,  102,   17,  102,
    425       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    426       102,  102,  102,  102,  102,  102,  102,   14,  102,  102,
    427 
    428       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    429       102,  102,  102,  102,  102,  102,   50,  102,  102,  102,
    430        63,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    431       102,  102,  102,  102,  102,   89,  102,  102,  102,  102,
    432       102,  102,  102,    0,    0,    0,    0,    0,    0,    0,
    433         0,  120,    0,    0,    0,    0,    0,  120,    0,    0,
    434       178,    0,    0,    0,    0,    0,    0,    0,  112,    0,
    435       112,    0,  112,    0,    0,  112,    0,  110,  110,    0,
    436         0,  111,  111,    0,  111,    0,  111,  109,  109,    0,
    437         0,    0,    0,    0,    0,    0,    0,    0,    0,  176,
    438 
    439       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    440       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    441       102,  102,  102,   21,  102,   24,  102,   27,  102,  102,
    442       102,  102,  102,  102,  102,   41,  102,   43,  102,  102,
    443       102,  102,  102,  102,  102,   55,  102,   66,  102,  102,
    444       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    445       102,  102,  102,  102,   97,  102,  102,    0,    0,    0,
     420        0,  134,  113,  113,    0,  113,  113,    0,    0,    6,
     421        0,  111,    0,    0,    0,  113,    0,  111,  111,  111,
     422      111,    0,  112,    0,    0,  110,  110,  110,  110,    0,
     423      172,  173,    0,  178,  176,    0,    0,    0,  104,    0,
     424        0,    0,    0,    0,    0,    0,    0,  103,   17,  103,
     425      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     426      103,  103,  103,  103,  103,  103,  103,   14,  103,  103,
     427
     428      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     429      103,  103,  103,  103,  103,  103,   51,  103,  103,  103,
     430       64,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     431      103,  103,  103,  103,  103,   90,  103,  103,  103,  103,
     432      103,  103,  103,    0,    0,    0,    0,    0,    0,    0,
     433        0,  121,    0,    0,    0,    0,    0,  121,    0,    0,
     434      179,    0,    0,    0,    0,    0,    0,    0,  113,    0,
     435      113,    0,  113,    0,    0,  113,    0,  111,  111,    0,
     436        0,  112,  112,    0,  112,    0,  112,  110,  110,    0,
     437        0,    0,    0,    0,    0,    0,    0,    0,    0,  177,
     438
     439      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     440      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     441      103,  103,  103,   21,  103,   24,  103,   27,  103,  103,
     442      103,  103,  103,  103,  103,   41,  103,   43,  103,  103,
     443      103,  103,  103,  103,  103,   56,  103,   67,  103,  103,
     444      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     445      103,  103,  103,  103,   98,  103,  103,    0,    0,    0,
    446446        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    447         0,  120,    0,    0,    0,    0,    0,  112,    0,    0,
    448         0,    0,    0,    0,  111,  111,    0,  113,    0,  111,
    449 
    450       111,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    451         0,    0,    0,    0,  102,  102,   22,  102,  102,  102,
    452       102,  102,  102,  102,   15,  102,  102,  102,  102,  102,
    453       102,  102,  102,  102,  102,  102,  102,  102,  102,   23,
    454        25,  102,   32,  102,  102,  102,  102,   40,  102,  102,
    455       102,  102,   48,  102,  102,   53,  102,  102,   70,  102,
    456       102,  102,   76,  102,  102,  102,  102,  102,   86,   88,
    457       102,  102,   94,  102,  102,  101,    0,    0,    0,    0,
     447        0,  121,    0,    0,    0,    0,    0,  113,    0,    0,
     448        0,    0,    0,    0,  112,  112,    0,  114,    0,  112,
     449
     450      112,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     451        0,    0,    0,    0,  103,  103,   22,  103,  103,  103,
     452      103,  103,  103,  103,   15,  103,  103,  103,  103,  103,
     453      103,  103,  103,  103,  103,  103,  103,  103,  103,   23,
     454       25,  103,   32,  103,  103,  103,  103,   40,  103,  103,
     455      103,  103,   49,  103,  103,   54,  103,  103,   71,  103,
     456      103,  103,   77,  103,  103,  103,  103,  103,   87,   89,
     457      103,  103,   95,  103,  103,  102,    0,    0,    0,    0,
    458458        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    459         0,    0,    0,    0,    0,  113,    0,    0,  111,  113,
    460 
    461       113,  113,  113,    0,  111,    0,    0,    0,    0,    0,
    462         0,    0,    0,    0,    0,  102,    0,  102,  102,  102,
    463       102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
    464       102,  102,  102,   58,  102,  102,  102,  102,  102,  102,
    465       102,  102,   28,  102,  102,  102,   39,   42,   45,  102,
    466       102,   51,  102,   60,   67,  102,  102,   75,   77,   80,
    467        81,   83,   84,  102,  102,   91,  102,  102,    0,    1,
    468         0,    0,    0,    0,    0,    0,  105,    0,    0,    0,
    469       120,    0,    0,    0,    0,  113,    0,  113,  113,    0,
    470         0,    0,    0,    0,    0,    0,    0,    0,  102,  102,
    471 
    472        18,  102,  102,  102,  102,  102,  102,  102,   16,  102,
    473       102,  102,   33,  102,  102,  102,  102,  102,  102,  102,
    474       102,  102,  102,  102,  102,   36,   37,  102,   47,   52,
    475       102,  102,  102,   90,  102,  102,    0,    0,    0,    0,
     459        0,    0,    0,    0,    0,  114,    0,    0,  112,  114,
     460
     461      114,  114,  114,    0,  112,    0,    0,    0,    0,    0,
     462        0,    0,    0,    0,    0,  103,    0,  103,  103,  103,
     463      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
     464      103,  103,  103,   59,  103,  103,  103,  103,  103,  103,
     465      103,  103,   28,  103,  103,  103,   39,   42,   45,  103,
     466      103,   52,  103,   61,   68,  103,  103,   76,   78,   81,
     467       82,   84,   85,  103,  103,   92,  103,  103,    0,    1,
     468        0,    0,    0,    0,    0,    0,  106,    0,    0,    0,
     469      121,    0,    0,    0,    0,  114,    0,  114,  114,    0,
     470        0,    0,    0,    0,    0,    0,    0,    0,  103,  103,
     471
     472       18,  103,  103,  103,  103,  103,  103,  103,   16,  103,
     473      103,  103,   33,  103,  103,  103,  103,  103,  103,  103,
     474      103,  103,  103,  103,  103,   36,   37,  103,   48,   53,
     475      103,  103,  103,   91,  103,  103,    0,    0,    0,    0,
    476476        0,    0,    0,    0,    0,    0,    0,    0,    0,   10,
    477        11,   29,   54,  102,  102,  102,  102,  102,  102,  102,
    478       102,  102,  102,  102,   59,   61,   64,  102,  102,   78,
    479        92,  102,  102,   35,   46,   71,   72,  102,   95,   98,
    480         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    481         0,    0,  102,   68,  102,  102,   12,  102,  102,   30,
    482 
    483        34,  102,  102,  102,   65,  102,  102,  102,  102,  102,
    484       102,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    485         0,    0,    0,    0,   57,  102,  102,  102,  102,  102,
    486       102,  102,   49,   62,   73,   79,   93,   99,  102,  102,
    487         0,    0,    0,    0,    0,    0,    0,    0,  102,  102,
    488        13,   19,  102,  102,   31,  102,  102,  102,   26,   87,
    489         0,    0,  102,  102,  102,  102,  102,  102,   74,  100,
    490       102,   85,   20,  102,  102,   44,   82,  102,  102,  102,
    491       102,  102,  102,  102,   96,   69,    0
     477       11,   29,   55,  103,  103,  103,  103,  103,  103,  103,
     478      103,  103,  103,  103,   60,   62,   65,  103,  103,   79,
     479       93,  103,  103,   35,  103,   47,   72,   73,  103,   96,
     480       99,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     481        0,    0,    0,  103,   69,  103,  103,   12,  103,  103,
     482
     483       30,   34,  103,  103,  103,   66,  103,  103,  103,  103,
     484      103,  103,  103,    0,    0,    0,    0,    0,    0,    0,
     485        0,    0,    0,    0,    0,    0,   58,  103,  103,  103,
     486      103,  103,  103,  103,   50,   63,   74,   80,   94,  100,
     487      103,  103,  103,    0,    0,    0,    0,    0,    0,    0,
     488        0,  103,  103,   13,   19,  103,  103,   31,  103,  103,
     489      103,   26,   46,   88,    0,    0,  103,  103,  103,  103,
     490      103,  103,   75,  101,  103,   86,   20,  103,  103,   44,
     491       83,  103,  103,  103,  103,  103,  103,  103,   97,   70,
     492        0
     493
    492494    } ;
    493495
     
    537539    } ;
    538540
    539 static yyconst flex_int16_t yy_base[1062] =
     541static yyconst flex_int16_t yy_base[1066] =
    540542    {   0,
    541         0,   84, 2272, 2269,   94,    0,  177,  178,  179,  180,
    542      2285, 2822,  191, 2822,  197,   55, 2822, 2231,   60,  173,
    543      2822, 2822, 2822,   56,  188, 2822,  191,  189,  204,  216,
    544       275,    0, 2249, 2822,  216, 2247,  152,  344,  155,  220,
    545      2822,  159, 2822,  217,  226, 2822,  185,  154,  212,  251,
     543        0,   84, 2285, 2282,   94,    0,  177,  178,  179,  180,
     544     2298, 2825,  191, 2825,  197,   55, 2825, 2244,   60,  173,
     545     2825, 2825, 2825,   56,  188, 2825,  191,  189,  204,  216,
     546      275,    0, 2262, 2825,  216, 2260,  152,  344,  155,  220,
     547     2825,  159, 2825,  217,  226, 2825,  185,  154,  212,  251,
    546548      237,  270,  235,  257,  241,  205,  193,  305,  314,  333,
    547       238,  228, 2822,  225, 2822, 2242,  402,  390, 2822, 2253,
    548      2822, 2221,  235, 2822,    0, 2822,  426,    0, 2822,  417,
    549      2822,  439,  451, 2822,  498, 2219,  264, 2822, 2822, 2822,
    550      2822, 2822, 2235, 2822, 2232, 2822, 2822, 2244,  559, 2822,
    551 
    552      2261, 2822,  438,  444,  511,  534,  289,  253,  197,  380,
    553       305,    0,  319,  280,  198,  322, 2822, 2822, 2822, 2230,
    554      2822, 2822, 2822, 2227, 2224,  218,  255, 2239,  298,  350,
    555       368,  312,  440,  398,  405, 2220,  441, 2168,  446, 2196,
    556      2822,  335, 2822, 2822,  468, 2190, 2189, 2822, 2162,  439,
     549      238,  228, 2825,  225, 2825, 2255,  402,  390, 2825, 2266,
     550     2825, 2234,  235, 2825,    0, 2825,  426,    0, 2825,  417,
     551     2825,  439,  451, 2825,  498, 2232,  264, 2825, 2825, 2825,
     552     2825, 2825, 2248, 2825, 2245, 2825, 2825, 2257,  559, 2825,
     553
     554     2274, 2825,  438,  444,  511,  534,  289,  253,  197,  380,
     555      305,    0,  319,  280,  198,  322, 2825, 2825, 2825, 2243,
     556     2825, 2825, 2825, 2240, 2237,  218,  255, 2252,  298,  350,
     557      368,  312,  440,  398,  405, 2233,  441, 2181,  446, 2209,
     558     2825,  335, 2825, 2825,  468, 2203, 2202, 2825, 2175,  439,
    557559      282,  433,  372,  281,  437,  434,  428,  570,  444,  466,
    558560      464,  469,  475,  321,  492,  438,  471,  445,  474,  512,
    559       489,  503,  496,  521,  276,  515,  516, 2189,  526,  510,
     561      489,  503,  496,  521,  276,  515,  516, 2202,  526,  510,
    560562      519,  525,  543,  522,  560,  553,  523,  561,  551,  544,
    561       599,  582,  593,  584, 2822, 2822,  660,  651, 2236,  666,
    562 
    563      2822,  678, 2822, 2183,  607, 2179, 2178,    0,  693, 2822,
    564      2822,  684, 2176, 2156, 2154,    0, 2177,  578,  608,  617,
    565       654,  679,  650,  683,  684,  687, 2172,  690,  691, 2147,
    566      2146, 2822,    0,  683,  710,  686,  700, 2145, 2196, 2822,
    567       714,    0,  427,  746,  764,  786,  808,  621, 2822, 2152,
    568      2125,    0,  794, 2171,  795,  709, 2822, 2147, 2121,  832,
    569      2822, 2822, 2152, 2822, 2822,  711,  714, 2129, 2129,  717,
    570      2125, 2123, 2120,    0, 2117,    0, 2088,  694,  679,  712,
     563      599,  582,  593,  584, 2825, 2825,  660,  651, 2249,  666,
     564
     565     2825,  678, 2825, 2196,  607, 2192, 2191,    0,  693, 2825,
     566     2825,  684, 2189, 2186, 2183,    0, 2206,  578,  608,  617,
     567      654,  679,  650,  683,  684,  687, 2203,  690,  691, 2179,
     568     2159, 2825,    0,  683,  710,  686,  700, 2157, 2209, 2825,
     569      714,    0,  427,  746,  764,  786,  808,  621, 2825, 2165,
     570     2138,    0,  794, 2184,  795,  709, 2825, 2160, 2134,  832,
     571     2825, 2825, 2165, 2825, 2825,  711,  714, 2142, 2142,  717,
     572     2138, 2136, 2133,    0, 2130,    0, 2101,  694,  679,  712,
    571573      709,  711,  698,  566,  726,  743,  771,  741,  790,  784,
    572       800,  795,  742,  744,  814,  816,  818, 2118,  819,  745,
     574      800,  795,  742,  744,  814,  816,  818, 2131,  819,  745,
    573575
    574576      820,  821,  822,  823,  824,  746,  825,  748,  659,  831,
    575577      826,  833,  838,  839,  848,  850,  851,  844,  834,  857,
    576      2116,  858,  859,  860,  862,  861,  864,  865,  867,  868,
    577       866,  871,  876,  872,  878, 2113,  880,  689,  881,  882,
    578       892,  896,  893,  953,  954, 2109, 2108, 2106,    0, 2103,
    579         0,  941,  945, 2102,    0, 2101,    0, 2099,    0, 2118,
    580      2822,  940,  941, 2094, 2088,    0, 2086,    0, 2822,  953,
    581       975,  964, 2822,  981,  997, 1021, 2084, 2822, 2822,  939,
    582       940, 1006,  982, 1041,  310, 1039, 1004, 2822, 2822, 2081,
    583      2079, 2077,    0, 2074,    0, 2071,    0, 2070,    0, 2822,
     578     2129,  858,  859,  860,  862,  861,  864,  865,  867,  868,
     579      866,  871,  876,  872,  878, 2126,  880,  689,  881,  882,
     580      892,  896,  893,  953,  954, 2120, 2119, 2118,    0, 2116,
     581        0,  941,  945, 2113,    0, 2112,    0, 2111,    0, 2131,
     582     2825,  940,  941, 2108, 2105,    0, 2104,    0, 2825,  953,
     583      975,  964, 2825,  981,  997, 1021, 2102, 2825, 2825,  939,
     584      940, 1006,  982, 1041,  310, 1039, 1004, 2825, 2825, 2099,
     585     2095, 2091,    0, 2089,    0, 2087,    0, 2084,    0, 2825,
    584586
    585587      886,  941,  960,  962,  977,  976,  980,  982, 1017, 1010,
    586588     1002,  998, 1022, 1031, 1028, 1033, 1034, 1037, 1040, 1043,
    587      1038, 1041, 1053, 2072, 1055, 2070, 1045, 2067, 1056, 1061,
    588      1063, 1065, 1066, 1067, 1070, 2064, 1071, 2063, 1073, 1074,
    589      1075, 1078, 1080, 1081, 1085, 2062, 1087, 2060, 1084, 1089,
     589     1038, 1041, 1053, 2085, 1055, 2083, 1045, 2080, 1056, 1061,
     590     1063, 1065, 1066, 1067, 1070, 2077, 1071, 2076, 1073, 1074,
     591     1075, 1078, 1080, 1081, 1085, 2075, 1087, 2073, 1084, 1089,
    590592     1091, 1097, 1099, 1092, 1102, 1103, 1105, 1106, 1108,  905,
    591      1109, 1116, 1110, 1122, 2057, 1120, 1123, 1179, 2051,    0,
    592      2050,    0, 2049,    0, 2047,    0, 1166, 2044,    0, 2041,
    593         0, 2040, 2039, 2037,    0, 2034,    0, 1173, 2031, 1179,
    594      1137, 1195, 1181, 1178, 1176, 2822, 1219, 1231, 1253, 2042,
    595 
    596      2017, 2027, 2024,    0, 2021,    0, 2020,    0, 2019,    0,
    597      2017,    0, 2014,    0, 1141, 1172, 2014, 1180, 1155, 1196,
     593     1109, 1116, 1110, 1122, 2070, 1120, 1123, 1179, 2064,    0,
     594     2063,    0, 2062,    0, 2060,    0, 1166, 2057,    0, 2054,
     595        0, 2053, 2052, 2050,    0, 2047,    0, 1173, 2044, 1179,
     596     1137, 1195, 1181, 1178, 1176, 2825, 1219, 1231, 1253, 2055,
     597
     598     2030, 2040, 2037,    0, 2034,    0, 2033,    0, 2032,    0,
     599     2030,    0, 2027,    0, 1141, 1172, 2027, 1180, 1155, 1196,
    598600     1157, 1216, 1207, 1231, 1125, 1210, 1232, 1214, 1187, 1236,
    599      1235, 1237, 1238, 1272, 1249, 1252, 1250, 1253, 1254, 2013,
    600      1261, 1256, 2012, 1260, 1263, 1264, 1257, 2010, 1271, 1268,
    601      1269, 1273, 2007, 1275, 1282, 2006, 1283, 1284, 2005, 1276,
    602      1286, 1289, 2003, 1294, 1291, 1296, 1295, 1297, 1310, 2000,
    603      1305, 1308, 1999, 1307, 1300, 1998, 2046, 1960,    0, 1958,
    604         0, 1957,    0, 1954,    0, 1951,    0, 1950,    0, 1949,
    605         0, 1947,    0, 1355, 1361, 1389, 1372, 1944, 2822, 1378,
    606 
    607      1325, 1365, 1379, 1941, 2822, 1940,    0, 1939,    0, 1937,
    608         0, 1934,    0,    0,    0, 1936,    0, 1366, 1312, 1311,
     601     1235, 1237, 1238, 1272, 1249, 1252, 1250, 1253, 1254, 2026,
     602     1261, 1256, 2025, 1260, 1263, 1264, 1257, 2023, 1271, 1268,
     603     1269, 1273, 2020, 1275, 1282, 2017, 1283, 1284, 2016, 1276,
     604     1286, 1289, 2015, 1294, 1291, 1296, 1295, 1297, 1310, 2013,
     605     1305, 1308, 2010, 1307, 1300, 2009, 2058, 2003,    0, 2000,
     606        0, 1999,    0, 1998,    0, 1996,    0, 1963,    0, 1961,
     607        0, 1960,    0, 1355, 1361, 1389, 1372, 1957, 2825, 1378,
     608
     609     1325, 1365, 1379, 1954, 2825, 1953,    0, 1952,    0, 1950,
     610        0, 1947,    0,    0,    0, 1947,    0, 1366, 1312, 1311,
    609611     1341, 1323, 1368, 1369, 1374, 1356, 1383, 1372, 1388, 1390,
    610612     1393, 1395, 1396, 1398, 1400, 1431, 1406, 1407, 1411, 1408,
    611      1413, 1414, 1935, 1409, 1416, 1419, 1933, 1930, 1929, 1422,
    612      1424, 1928, 1429, 1926, 1923, 1425, 1430, 1919, 1915, 1911,
    613      1895, 1894, 1893, 1436, 1433, 1891, 1439, 1440, 1938, 2822,
    614      1884,    0, 1883,    0,    0,    0, 1884,    0,    0,    0,
    615      2822,    0,    0,    0,    0, 1486, 1878, 2822, 2822, 1492,
    616      1877,    0, 1876,    0,    0,    0,    0, 1874, 1447, 1444,
    617 
    618      1874, 1449, 1471, 1479, 1450, 1480, 1482, 1469, 1873, 1486,
     613     1413, 1414, 1946, 1409, 1416, 1419, 1945, 1943, 1940, 1422,
     614     1424, 1939, 1429, 1938, 1936, 1425, 1430, 1933, 1932, 1931,
     615     1929, 1926, 1922, 1436, 1433, 1918, 1439, 1440, 1964, 2825,
     616     1895,    0, 1894,    0,    0,    0, 1896,    0,    0,    0,
     617     2825,    0,    0,    0,    0, 1486, 1891, 2825, 2825, 1492,
     618     1888,    0, 1887,    0,    0,    0,    0, 1886, 1447, 1444,
     619
     620     1887, 1449, 1471, 1479, 1450, 1480, 1482, 1469, 1884, 1486,
    619621     1490, 1488, 1502, 1452, 1510, 1504, 1491, 1519, 1506, 1498,
    620      1508, 1512, 1513, 1514, 1515, 1872, 1870, 1517, 1867, 1866,
    621      1518, 1520, 1523, 1865, 1521, 1525,    0,    0,    0, 1860,
    622      1857, 1856, 1575,    0, 1855, 1853, 1850, 1849, 1848, 1849,
    623      1846, 1845, 1844, 1531, 1536, 1527, 1528, 1552, 1533, 1537,
    624      1539, 1555, 1557, 1569, 1842, 1560, 1839, 1561, 1559, 1568,
    625      1572, 1567, 1573, 1838, 1837, 1835, 1828, 1574, 1826, 1825,
    626      1819, 1818, 1817, 1815, 1798, 1789, 1788, 1785, 1778, 1775,
    627      1768, 1766, 1576, 1768, 1577, 1581, 1580, 1579, 1584, 1585,
    628 
    629      1747, 1586, 1615, 1590, 1746, 1591, 1592, 1602, 1600, 1594,
    630      1606, 1742, 1735, 1733, 1732, 1690, 1689, 1686, 1685, 1683,
    631      1682, 1678, 1677, 1674, 1676, 1607, 1611, 1614, 1612, 1608,
    632      1616, 1620, 1675, 1623, 1624, 1530, 1453, 1630, 1625, 1629,
    633      1438, 1354, 1319, 1318, 1267, 1212, 1210, 1208, 1631, 1636,
    634      1178, 1639, 1635, 1643, 1177, 1644, 1646, 1650, 1126,  964,
    635       937,  903, 1651, 1652, 1654, 1655, 1656, 1658,  788,  752,
    636      1660,  607,  487, 1662, 1663,  394,  357, 1664, 1666, 1668,
    637      1670, 1669, 1672, 1674,  233,  137, 2822, 1747, 1760, 1773,
    638      1783, 1793, 1806, 1816, 1829, 1842, 1855, 1863, 1873, 1880,
    639 
    640      1887, 1894, 1901, 1908, 1915, 1922, 1929, 1936, 1949, 1956,
    641      1960, 1968, 1971, 1978, 1985, 1992, 1995, 2002, 2008, 2021,
    642      2034, 2041, 2048, 2055, 2062, 2065, 2072, 2075, 2082, 2085,
    643      2092, 2095, 2102, 2105, 2112, 2115, 2122, 2125, 2132, 2140,
    644      2147, 2154, 2161, 2168, 2171, 2178, 2181, 2188, 2191, 2198,
    645      2204, 2217, 2224, 2231, 2234, 2241, 2244, 2251, 2254, 2261,
    646      2264, 2271, 2274, 2281, 2284, 2291, 2298, 2301, 2308, 2311,
    647      2318, 2325, 2332, 2335, 2342, 2345, 2352, 2355, 2362, 2365,
    648      2372, 2375, 2382, 2388, 2401, 2408, 2415, 2418, 2425, 2428,
    649      2435, 2438, 2445, 2448, 2455, 2458, 2465, 2468, 2475, 2478,
    650 
    651      2485, 2488, 2495, 2502, 2505, 2512, 2515, 2522, 2525, 2532,
    652      2535, 2538, 2544, 2551, 2560, 2567, 2574, 2577, 2584, 2587,
    653      2590, 2596, 2603, 2606, 2609, 2612, 2615, 2618, 2621, 2624,
    654      2631, 2634, 2641, 2644, 2647, 2650, 2653, 2663, 2670, 2673,
    655      2676, 2679, 2686, 2693, 2700, 2703, 2710, 2717, 2724, 2731,
    656      2738, 2745, 2752, 2759, 2766, 2773, 2780, 2787, 2794, 2801,
    657      2808
     622     1508, 1512, 1513, 1514, 1515, 1883, 1882, 1518, 1880, 1877,
     623     1517, 1520, 1523, 1876, 1521, 1525,    0,    0,    0, 1872,
     624     1870, 1867, 1575,    0, 1866, 1865, 1863, 1860, 1859, 1861,
     625     1859, 1856, 1855, 1531, 1538, 1527, 1528, 1530, 1533, 1552,
     626     1539, 1554, 1553, 1586, 1854, 1559, 1852, 1560, 1561, 1564,
     627     1570, 1572, 1571, 1849, 1574, 1848, 1847, 1845, 1575, 1842,
     628     1841, 1837, 1835, 1828, 1826, 1825, 1822, 1821, 1820, 1818,
     629     1801, 1792, 1791, 1576, 1791, 1579, 1577, 1580, 1582, 1581,
     630
     631     1585, 1784, 1589, 1616, 1593, 1781, 1591, 1599, 1605, 1592,
     632     1606, 1609, 1610, 1771, 1769, 1768, 1747, 1746, 1745, 1738,
     633     1736, 1735, 1693, 1689, 1688, 1687, 1689, 1611, 1612, 1614,
     634     1615, 1618, 1625, 1621, 1686, 1683, 1627, 1682, 1681, 1631,
     635     1635, 1441, 1637, 1677, 1674, 1354, 1319, 1318, 1267, 1212,
     636     1210, 1639, 1640, 1211, 1647, 1623, 1649, 1178, 1652, 1653,
     637     1657, 1177, 1126,  964,  937,  903, 1641, 1643, 1659, 1663,
     638     1664, 1665,  788,  752, 1629,  607,  487, 1666, 1669,  394,
     639      357, 1670, 1672, 1671, 1674, 1676, 1675, 1678,  233,  137,
     640     2825, 1750, 1763, 1776, 1786, 1796, 1809, 1819, 1832, 1845,
     641
     642     1858, 1866, 1876, 1883, 1890, 1897, 1904, 1911, 1918, 1925,
     643     1932, 1939, 1952, 1959, 1963, 1971, 1974, 1981, 1988, 1995,
     644     1998, 2005, 2011, 2024, 2037, 2044, 2051, 2058, 2065, 2068,
     645     2075, 2078, 2085, 2088, 2095, 2098, 2105, 2108, 2115, 2118,
     646     2125, 2128, 2135, 2143, 2150, 2157, 2164, 2171, 2174, 2181,
     647     2184, 2191, 2194, 2201, 2207, 2220, 2227, 2234, 2237, 2244,
     648     2247, 2254, 2257, 2264, 2267, 2274, 2277, 2284, 2287, 2294,
     649     2301, 2304, 2311, 2314, 2321, 2328, 2335, 2338, 2345, 2348,
     650     2355, 2358, 2365, 2368, 2375, 2378, 2385, 2391, 2404, 2411,
     651     2418, 2421, 2428, 2431, 2438, 2441, 2448, 2451, 2458, 2461,
     652
     653     2468, 2471, 2478, 2481, 2488, 2491, 2498, 2505, 2508, 2515,
     654     2518, 2525, 2528, 2535, 2538, 2541, 2547, 2554, 2563, 2570,
     655     2577, 2580, 2587, 2590, 2593, 2599, 2606, 2609, 2612, 2615,
     656     2618, 2621, 2624, 2627, 2634, 2637, 2644, 2647, 2650, 2653,
     657     2656, 2666, 2673, 2676, 2679, 2682, 2689, 2696, 2703, 2706,
     658     2713, 2720, 2727, 2734, 2741, 2748, 2755, 2762, 2769, 2776,
     659     2783, 2790, 2797, 2804, 2811
    658660    } ;
    659661
    660 static yyconst flex_int16_t yy_def[1062] =
     662static yyconst flex_int16_t yy_def[1066] =
    661663    {   0,
    662       887,    1,  888,  888,  887,    5,  889,  889,  890,  890,
    663       887,  887,  887,  887,  887,  887,  887,  891,  887,  887,
    664       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    665       887,   31,  887,  887,  887,  887,  887,  887,  892,  891,
    666       887,  887,  887,  887,  891,  887,  891,  891,  891,  891,
     664      891,    1,  892,  892,  891,    5,  893,  893,  894,  894,
     665      891,  891,  891,  891,  891,  891,  891,  895,  891,  891,
    667666      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
    668       891,  891,  887,  887,  887,  887,  887,  893,  887,  887,
    669       887,  894,  887,  887,  895,  887,  887,  896,  887,  887,
    670       887,  887,  887,  887,  887,  891,  887,  887,  887,  887,
    671       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    672 
    673       897,  887,   99,   30,  887,  887,  887,  887,  898,   30,
    674       887,   31,  887,  887,   31,  887,  887,  887,  887,  887,
    675       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    676       887,  887,  887,  887,  887,  887,  887,  887,  887,  899,
    677       887,  887,  887,  887,  891,  900,  901,  887,  887,  891,
     667      891,   31,  891,  891,  891,  891,  891,  891,  896,  895,
     668      891,  891,  891,  891,  895,  891,  895,  895,  895,  895,
     669      895,  895,  895,  895,  895,  895,  895,  895,  895,  895,
     670      895,  895,  891,  891,  891,  891,  891,  897,  891,  891,
     671      891,  898,  891,  891,  899,  891,  891,  900,  891,  891,
     672      891,  891,  891,  891,  891,  895,  891,  891,  891,  891,
     673      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     674
     675      901,  891,   99,   30,  891,  891,  891,  891,  902,   30,
     676      891,   31,  891,  891,   31,  891,  891,  891,  891,  891,
     677      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     678      891,  891,  891,  891,  891,  891,  891,  891,  891,  903,
     679      891,  891,  891,  891,  895,  904,  905,  891,  891,  895,
     680      895,  895,  895,  895,  895,  895,  895,  895,  895,  895,
     681      895,  895,  895,  895,  895,  895,  895,  895,  895,  895,
     682      895,  895,  895,  895,  895,  895,  895,  895,  895,  895,
     683      895,  895,  895,  895,  895,  895,  895,  895,  895,  895,
     684      895,  895,  895,  895,  891,  891,  891,  897,  897,  897,
     685
     686      891,  897,  891,  898,  891,  906,  907,  899,  891,  891,
     687      891,  891,  908,  909,  910,  900,  891,  891,  891,  891,
     688      891,  891,  891,  891,  891,  891,  891,  891,  891,  911,
     689      912,  891,   99,  891,  891,  891,  891,   99,  913,  891,
     690      891,  104,  104,  891,  891,  891,  891,  891,  891,  891,
     691      891,  914,  915,  916,  891,  891,  891,  891,  891,  891,
     692      891,  891,  891,  891,  891,  891,  891,  891,  903,  891,
     693      917,  918,  919,  920,  921,  922,  891,  923,  923,  923,
     694      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     695      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     696
     697      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     698      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     699      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     700      923,  923,  923,  923,  923,  923,  923,  923,  923,  923,
     701      923,  923,  923,  924,  925,  926,  927,  928,  929,  930,
     702      931,  891,  891,  932,  933,  934,  935,  936,  937,  891,
     703      891,  891,  891,  891,  938,  939,  940,  941,  891,  891,
     704      891,  891,  891,  891,  891,  371,  376,  891,  891,  942,
     705      943,  944,  891,  891,  891,  944,  891,  891,  891,  945,
     706      946,  947,  948,  949,  950,  951,  952,  953,  954,  891,
     707
     708      955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
     709      955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
     710      955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
     711      955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
     712      955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
     713      955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
     714      955,  955,  955,  955,  955,  955,  955,  956,  957,  958,
     715      959,  960,  961,  962,  963,  964,  891,  965,  966,  967,
     716      968,  969,  969,  970,  971,  972,  973,  891,  488,  891,
     717      974,  891,  974,  891,  891,  891,  891,  891,  891,  891,
     718
     719      891,  975,  976,  977,  978,  979,  980,  981,  982,  983,
     720      984,  985,  986,  987,  988,  988,  988,  988,  988,  988,
     721      988,  988,  988,  988,  988,  988,  988,  988,  988,  988,
     722      988,  988,  988,  988,  988,  988,  988,  988,  988,  988,
     723      988,  988,  988,  988,  988,  988,  988,  988,  988,  988,
     724      988,  988,  988,  988,  988,  988,  988,  988,  988,  988,
     725      988,  988,  988,  988,  988,  988,  988,  988,  988,  988,
     726      988,  988,  988,  988,  988,  988,  989,  990,  991,  992,
     727      993,  994,  995,  996,  997,  998,  999, 1000, 1001, 1002,
     728     1003, 1004, 1005,  891,  891,  891,  891, 1006,  891,  596,
     729
     730      891,  891,  891,  600,  891, 1007, 1008, 1009, 1010, 1011,
     731     1012, 1013, 1014, 1015, 1016, 1017, 1018, 1017, 1017, 1017,
     732     1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017,
     733     1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017,
     734     1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017,
     735     1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017,
     736     1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1019,  891,
     737     1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029,
     738      891, 1030, 1031, 1032, 1033,  891,  686,  891,  891,  891,
     739     1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1042,
     740
     741     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     742     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     743     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     744     1042, 1042, 1042, 1042, 1042, 1042, 1043, 1044, 1045, 1046,
     745     1047, 1048,  891, 1049, 1034, 1036, 1050, 1051, 1041, 1042,
     746     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     747     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     748     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     749     1042, 1052, 1053, 1046, 1054, 1047, 1055, 1048, 1056, 1057,
     750     1050, 1058, 1051, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     751
     752     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     753     1042, 1042, 1042, 1059, 1052, 1060, 1053, 1061, 1054, 1062,
     754     1055, 1063, 1056, 1064, 1057, 1058, 1042, 1042, 1042, 1042,
     755     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     756     1042, 1042, 1042, 1065, 1059, 1060, 1061, 1062, 1036, 1063,
     757     1064, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     758     1042, 1042, 1042, 1042, 1065, 1036, 1042, 1042, 1042, 1042,
     759     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     760     1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
     761        0,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     762
    678763      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
    679764      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
    680765      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
    681766      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
    682       891,  891,  891,  891,  887,  887,  887,  893,  893,  893,
    683 
    684       887,  893,  887,  894,  887,  902,  903,  895,  887,  887,
    685       887,  887,  904,  905,  906,  896,  887,  887,  887,  887,
    686       887,  887,  887,  887,  887,  887,  887,  887,  887,  907,
    687       908,  887,   99,  887,  887,  887,  887,   99,  909,  887,
    688       887,  104,  104,  887,  887,  887,  887,  887,  887,  887,
    689       887,  910,  911,  912,  887,  887,  887,  887,  887,  887,
    690       887,  887,  887,  887,  887,  887,  887,  887,  899,  887,
    691       913,  914,  915,  916,  917,  918,  887,  919,  919,  919,
    692       919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
    693       919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
    694 
    695       919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
    696       919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
    697       919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
    698       919,  919,  919,  919,  919,  919,  919,  919,  919,  919,
    699       919,  919,  919,  920,  921,  922,  923,  924,  925,  926,
    700       927,  887,  887,  928,  929,  930,  931,  932,  933,  887,
    701       887,  887,  887,  887,  934,  935,  936,  937,  887,  887,
    702       887,  887,  887,  887,  887,  371,  376,  887,  887,  938,
    703       939,  940,  887,  887,  887,  940,  887,  887,  887,  941,
    704       942,  943,  944,  945,  946,  947,  948,  949,  950,  887,
    705 
    706       951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
    707       951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
    708       951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
    709       951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
    710       951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
    711       951,  951,  951,  951,  951,  951,  951,  951,  951,  951,
    712       951,  951,  951,  951,  951,  951,  951,  952,  953,  954,
    713       955,  956,  957,  958,  959,  960,  887,  961,  962,  963,
    714       964,  965,  965,  966,  967,  968,  969,  887,  488,  887,
    715       970,  887,  970,  887,  887,  887,  887,  887,  887,  887,
    716 
    717       887,  971,  972,  973,  974,  975,  976,  977,  978,  979,
    718       980,  981,  982,  983,  984,  984,  984,  984,  984,  984,
    719       984,  984,  984,  984,  984,  984,  984,  984,  984,  984,
    720       984,  984,  984,  984,  984,  984,  984,  984,  984,  984,
    721       984,  984,  984,  984,  984,  984,  984,  984,  984,  984,
    722       984,  984,  984,  984,  984,  984,  984,  984,  984,  984,
    723       984,  984,  984,  984,  984,  984,  984,  984,  984,  984,
    724       984,  984,  984,  984,  984,  984,  985,  986,  987,  988,
    725       989,  990,  991,  992,  993,  994,  995,  996,  997,  998,
    726       999, 1000, 1001,  887,  887,  887,  887, 1002,  887,  596,
    727 
    728       887,  887,  887,  600,  887, 1003, 1004, 1005, 1006, 1007,
    729      1008, 1009, 1010, 1011, 1012, 1013, 1014, 1013, 1013, 1013,
    730      1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013,
    731      1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013,
    732      1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013,
    733      1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013,
    734      1013, 1013, 1013, 1013, 1013, 1013, 1013, 1013, 1015,  887,
    735      1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025,
    736       887, 1026, 1027, 1028, 1029,  887,  686,  887,  887,  887,
    737      1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1038,
    738 
    739      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    740      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    741      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    742      1038, 1038, 1038, 1038, 1038, 1038, 1039, 1040, 1041, 1042,
    743      1043, 1044,  887, 1045, 1030, 1032, 1046, 1047, 1037, 1038,
    744      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    745      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    746      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    747      1048, 1049, 1042, 1050, 1043, 1051, 1044, 1052, 1053, 1046,
    748      1054, 1047, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    749 
    750      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    751      1038, 1055, 1048, 1056, 1049, 1057, 1050, 1058, 1051, 1059,
    752      1052, 1060, 1053, 1054, 1038, 1038, 1038, 1038, 1038, 1038,
    753      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    754      1061, 1055, 1056, 1057, 1058, 1032, 1059, 1060, 1038, 1038,
    755      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    756      1061, 1032, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    757      1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038, 1038,
    758      1038, 1038, 1038, 1038, 1038, 1038,    0,  887,  887,  887,
    759       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    760 
    761       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    762       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    763       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    764       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    765       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    766       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    767       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    768       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    769       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    770       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    771 
    772       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    773       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    774       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    775       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    776       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    777       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    778       887
     767      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     768      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     769      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     770      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     771      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     772      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     773
     774      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     775      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     776      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     777      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     778      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     779      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     780      891,  891,  891,  891,  891
    779781    } ;
    780782
    781 static yyconst flex_int16_t yy_nxt[2908] =
     783static yyconst flex_int16_t yy_nxt[2911] =
    782784    {   0,
    783785       12,   13,   14,   15,   15,   15,   13,   16,   17,   12,
     
    804806
    805807       83,   83,   83,   82,   91,   93,   87,  142,  146,   98,
    806        95,   99,   99,   99,   99,   99,   99,  252,  887,   94,
     808       95,   99,   99,   99,   99,   99,   99,  252,  891,   94,
    807809      100,   85,   96,   97,   85,  101,  161,  118,  143,   77,
    808810       77,   77,   77,  144,  147,  102,  103,   87,  104,  104,
     
    825827      305,  200,  201,  190,  257,  136,  200,  257,  137,  263,
    826828
    827       887,  264,  192,  197,   81,   82,   82,   82,  197,   87,
     829      891,  264,  192,  197,   81,   82,   82,   82,  197,   87,
    828830      272,  198,  202,  202,  202,  202,  202,  202,   80,   81,
    829831       82,   82,   82,   80,   87,  138,  139,  209,  210,  263,
    830       887,  264,  209,  282,  211,  255,  263,  267,  264,  211,
    831        82,   81,   82,   82,   82,   82,   87,  887,  212,  212,
    832       212,  212,   82,   81,   83,   83,   83,   82,  887,  211,
     832      891,  264,  209,  282,  211,  255,  263,  267,  264,  211,
     833       82,   81,   82,   82,   82,   82,   87,  891,  212,  212,
     834      212,  212,   82,   81,   83,   83,   83,   82,  891,  211,
    833835       99,   99,   99,   99,   99,   99,  242,  242,  242,  242,
    834836      266,  263,  263,  264,  264,  213,  143,  263,  211,  264,
    835837       87,  144,  375,  211,  211,   87,   87,  211,  211,   87,
    836        87,   87,  286,  241,  887,  211,   87,   87,  211,  243,
     838       87,   87,  286,  241,  891,  211,   87,   87,  211,  243,
    837839
    838840      211,  214,  211,  281,  215,  217,  278,  284,  285,  218,
    839841      219,  307,  298,  279,  220,  221,   87,  222,   87,  223,
    840        87,   87,  887,   87,  309,  300,   87,   87,  224,  225,
     842       87,   87,  891,   87,  309,  300,   87,   87,  224,  225,
    841843      226,  103,  303,  105,  105,  105,  105,  105,  105,   87,
    842844      299,   87,  301,  302,   87,  304,  308,  310,   87,  227,
     
    885887       87,  450,   87,   87,   87,  452,  455,  454,   87,  453,
    886888      457,  462,  460,  461,   87,   87,  458,  464,   87,  515,
    887       459,  463,  465,  466,  344,  201,  201,   87,  887,  344,
     889      459,  463,  465,  466,  344,  201,  201,   87,  891,  344,
    888890      467,  345,  199,  211,  211,  211,  211,  352,  352,  352,
    889891      352,  360,  360,  361,  361,  371,  371,  371,  371,  371,
    890892      371,  370,  569,  370,  492,  492,  371,  371,  371,  371,
    891       371,  371,  887,   87,  493,  494,  477,  488,  488,  488,
     893      371,  371,  891,   87,  493,  494,  477,  488,  488,  488,
    892894
    893895      488,  488,  488,  233,  233,  233,  233,  233,  233,  516,
     
    896898      489,  496,   87,  518,   87,  236,  374,  236,  519,  520,
    897899      237,  521,  236,  376,  376,  376,  376,  376,  376,  383,
    898        87,  384,  375,  496,   87,  385,  522,  496,  497,  887,
     900       87,  384,  375,  496,   87,  385,  522,  496,  497,  891,
    899901      497,  386,   87,  498,  498,  498,  498,  498,  498,   87,
    900902      525,  495,  526,  387,   87,  524,  377,  384,  523,  496,
     
    919921      236,  498,  498,  498,  498,  498,  498,  620,   87,  492,
    920922      597,  599,  492,  600,  600,  600,  600,  600,  600,   87,
    921       631,  622,   87,  887,  625,  887,   87,  862,   87,  601,
     923      631,  622,   87,   87,  625,  891,   87,  891,   87,  601,
    922924      497,  602,  497,  603,  602,  498,  498,  498,  498,  498,
    923925      498,  624,  628,   87,   87,  630,  604,   87,   87,   87,
     
    926928      634,   87,   87,  635,   87,   87,   87,  642,   87,   87,
    927929      637,  641,   87,   87,  640,   87,   87,  643,  647,  639,
    928        87,   87,  887,   87,   87,   87,  638,   87,   87,  644,
     930       87,   87,  866,   87,   87,   87,  638,   87,   87,  644,
    929931      645,  646,  648,  650,   87,   87,   87,  649,   87,  653,
    930932      651,   87,  652,   87,  654,  655,   87,   87,   87,   87,
    931933      656,  657,   87,  660,  659,  661,  664,   87,  658,   87,
    932934       87,  663,   87,   87,   87,  668,  665,  688,  688,  662,
    933       666,  701,  702,  887,  887,   87,  667,  488,  488,  488,
     935      666,  701,  702,  891,  891,   87,  667,  488,  488,  488,
    934936      488,  488,  488,  596,  596,  596,  596,  596,  596,  595,
    935937      688,  595,  704,   87,  596,  596,  596,  596,  596,  596,
    936938
    937       600,  600,  600,  600,  600,  600,  703,  688,   87,  887,
     939      600,  600,  600,  600,  600,  600,  703,  688,   87,  891,
    938940      594,  686,  686,  686,  686,  686,  686,  689,   87,  689,
    939941       87,   87,  689,  699,   87,  708,   87,  601,  706,  602,
     
    944946      715,   87,  721,  719,   87,  724,   87,   87,  722,  720,
    945947      727,   87,   87,   87,  725,   87,  731,  723,   87,  732,
    946       726,   87,   87,  861,  728,  734,   87,  733,  730,   87,
    947 
    948       735,   87,   87,  729,   87,   87,  751,  736,  686,  686,
     948      726,   87,   87,   87,  728,  734,   87,  733,  730,   87,
     949
     950      735,   87,   87,  729,   87,  863,  751,  736,  686,  686,
    949951      686,  686,  686,  686,  600,  600,  600,  600,  600,  600,
    950952      750,   87,  755,   87,  601,  763,  602,  752,  603,  602,
     
    954956       87,  768,   87,  769,   87,   87,   87,   87,  770,   87,
    955957       87,   87,   87,   87,  771,   87,  774,   87,  772,   87,
    956        87,  779,   87,   87,  795,   87,  780,  773,   87,   87,
    957       776,   87,  775,  803,  777,  796,  778,  686,  686,  686,
    958 
    959       686,  686,  686,  793,   87,  794,  799,   87,  798,   87,
    960       801,   87,   87,   87,  797,  804,  805,  800,  806,   87,
    961        87,   87,  802,  807,   87,   87,   87,  808,   87,   87,
    962       743,   87,   87,   87,  809,  828,   87,   87,   87,  830,
    963       831,  833,   87,   87,   87,  834,   87,  836,  810,  811,
    964       826,  827,   87,  829,   87,  825,  832,  837,   87,   87,
    965        87,  838,  839,   87,   87,  835,   87,   87,   87,  851,
    966       850,  855,   87,  852,  840,   87,   87,   87,  853,  857,
    967       849,   87,   87,   87,  854,  858,  859,   87,   87,  856,
    968       860,   87,  863,  864,  865,   87,   87,  866,   87,  868,
    969 
    970       867,  869,   87,   87,   87,  870,   87,   87,   87,  873,
    971        87,  875,   87,  876,   87,   87,   87,  874,   87,  872,
    972        87,   87,   87,  871,   87,  880,   87,   87,   87,  887,
    973       879,  881,  887,  848,  877,  878,  886,  887,  847,  884,
    974       887,  845,  882,  883,  887,  844,  885,   69,   69,   69,
     958       87,  780,   87,   87,  796,   87,  781,  773,  775,  777,
     959       87,   87,  798,  776,  778,  797,  779,  686,  686,  686,
     960
     961      686,  686,  686,  794,   87,   87,   87,  795,  799,  802,
     962      804,   87,   87,   87,  805,  806,   87,  801,  803,  808,
     963      807,  800,   87,   87,   87,  809,   87,   87,   87,   87,
     964      743,   87,   87,   87,   87,  830,  832,   87,   87,  810,
     965      833,   87,  835,   87,   87,   87,  811,  829,  836,  812,
     966      813,   87,  828,  840,  838,  827,  831,   87,   87,  834,
     967      839,   87,   87,   87,   87,  837,   87,   87,   87,  854,
     968       87,  853,  842,   87,  841,   87,  855,   87,  843,   87,
     969      858,   87,  860,   87,  852,  870,  861,   87,  856,   87,
     970      859,   87,   87,   87,  857,   87,  862,  868,  864,   87,
     971
     972      867,   87,  869,  881,   87,   87,  871,  872,  873,   87,
     973      876,   87,  874,  875,  877,   87,   87,   87,   87,  879,
     974      880,   87,   87,   87,   87,  878,   87,   87,   87,  891,
     975       87,  884,  865,   87,   87,   87,  883,  885,   87,  882,
     976      890,   87,  891,  891,  851,  886,  888,  887,  891,  889,
    975977       69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
    976        75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
    977        75,   75,   75,   78,   78,   78,   78,   78,   78,   78,
    978        78,   78,   78,   78,   78,   78,   86,  887,  843,   86,
    979       887,   86,   86,   86,   86,   86,  140,  842,   87,   87,
    980 
    981       140,  140,  140,  140,  140,  140,  199,  199,  199,  199,
    982       199,  199,  199,  199,  199,  199,  199,  199,  199,  204,
    983        87,  887,  204,  824,  204,  204,  204,  204,  204,  208,
    984       887,  208,  208,  823,  208,  208,  208,  208,  208,  208,
    985       821,  208,  216,  887,  819,  216,  216,  216,  216,  216,
    986       216,  216,  216,  887,  216,  239,  239,  239,  239,  239,
    987       239,  239,  239,  239,  239,  239,  239,  239,  253,  253,
    988       817,  253,  887,  815,  813,  253,  269,   87,   87,  269,
    989        87,  269,  269,  269,  269,  269,  273,   87,  273,   87,
    990        87,   87,  273,  275,   87,  275,   87,   87,   87,  275,
    991 
    992       348,   87,  348,  887,  792,  790,  348,  350,  887,  350,
    993       887,  787,  785,  350,  354,  783,  354,   87,   87,   87,
    994       354,  356,   87,  356,   87,   87,   87,  356,  358,  749,
    995       358,  746,  745,  743,  358,  365,  205,  365,  739,  738,
    996       670,  365,  367,   87,  367,   87,   87,   87,  367,  239,
     978       69,   69,   69,   75,   75,   75,   75,   75,   75,   75,
     979       75,   75,   75,   75,   75,   75,   78,   78,   78,   78,
     980       78,   78,   78,   78,   78,   78,   78,   78,   78,   86,
     981      850,  891,   86,  848,   86,   86,   86,   86,   86,  140,
     982
     983      891,  847,  891,  140,  140,  140,  140,  140,  140,  199,
     984      199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
     985      199,  199,  204,  846,  891,  204,  845,  204,  204,  204,
     986      204,  204,  208,   87,  208,  208,   87,  208,  208,  208,
     987      208,  208,  208,   87,  208,  216,  891,  826,  216,  216,
     988      216,  216,  216,  216,  216,  216,  891,  216,  239,  239,
    997989      239,  239,  239,  239,  239,  239,  239,  239,  239,  239,
    998       239,  239,  380,   87,  380,  382,  382,   87,  382,  382,
    999       382,   87,  382,  253,  253,   87,  253,  392,   87,  392,
    1000        87,   87,   87,  392,  394,   87,  394,   87,   87,  697,
    1001       394,  396,  696,  396,  694,  692,  690,  396,  273,  598,
    1002 
    1003       273,  398,  685,  398,  684,  682,  680,  398,  275,  678,
    1004       275,   86,  676,  674,   86,  672,   86,   86,   86,   86,
    1005        86,  199,  199,  199,  199,  199,  199,  199,  199,  199,
    1006       199,  199,  199,  199,  468,  468,  468,  468,  468,  468,
    1007       468,  468,  468,  468,  468,  468,  468,  469,  670,  469,
    1008        87,   87,   87,  469,  471,   87,  471,   87,   87,   87,
    1009       471,  473,   87,  473,   87,   87,   87,  473,  348,  617,
    1010       348,  475,  615,  475,  613,  611,  609,  475,  350,  607,
    1011       350,  478,  502,  478,  605,  605,  594,  478,  354,  593,
    1012       354,  480,  591,  480,  483,  483,  589,  480,  356,  587,
    1013 
    1014       356,  482,  585,  482,  583,  581,  579,  482,  358,   87,
    1015       358,  484,   87,  484,   87,   87,   87,  484,  365,   87,
    1016       365,  486,   87,  486,   87,  514,  512,  486,  367,  510,
    1017       367,  491,  508,  491,  506,  491,  504,  491,  380,  490,
    1018       380,  487,  380,  485,  380,  382,  382,  361,  382,  382,
    1019       382,  361,  382,  503,  483,  503,  481,  479,  476,  503,
    1020       505,  474,  505,  472,  470,   87,  505,  507,   87,  507,
    1021        87,  400,  399,  507,  392,  397,  392,  509,  395,  509,
    1022       393,  270,  265,  509,  394,  264,  394,  511,  389,  511,
    1023       389,  252,  379,  511,  396,  379,  396,  513,  240,  513,
    1024 
    1025       374,  368,  366,  513,  398,  364,  398,   86,  360,  359,
    1026        86,  357,   86,   86,   86,   86,   86,  468,  468,  468,
     990      239,  253,  253,  825,  253,  823,  891,  821,  253,  269,
     991      891,  819,  269,  891,  269,  269,  269,  269,  269,  273,
     992      817,  273,  815,   87,   87,  273,  275,   87,  275,   87,
     993
     994       87,   87,  275,  348,   87,  348,   87,   87,   87,  348,
     995      350,   87,  350,   87,  891,  793,  350,  354,  791,  354,
     996      891,  891,  788,  354,  356,  786,  356,  784,   87,   87,
     997      356,  358,   87,  358,   87,   87,   87,  358,  365,   87,
     998      365,  749,  746,  745,  365,  367,  743,  367,  205,  739,
     999      738,  367,  239,  239,  239,  239,  239,  239,  239,  239,
     1000      239,  239,  239,  239,  239,  380,  670,  380,  382,  382,
     1001       87,  382,  382,  382,   87,  382,  253,  253,   87,  253,
     1002      392,   87,  392,   87,   87,   87,  392,  394,   87,  394,
     1003       87,   87,   87,  394,  396,   87,  396,   87,   87,   87,
     1004
     1005      396,  273,  697,  273,  398,  696,  398,  694,  692,  690,
     1006      398,  275,  598,  275,   86,  685,  684,   86,  682,   86,
     1007       86,   86,   86,   86,  199,  199,  199,  199,  199,  199,
     1008      199,  199,  199,  199,  199,  199,  199,  468,  468,  468,
    10271009      468,  468,  468,  468,  468,  468,  468,  468,  468,  468,
    1028       578,  355,  578,  351,  349,  205,  578,  469,  201,  469,
    1029       580,   87,  580,  277,  276,  274,  580,  471,  270,  471,
    1030       582,  265,  582,  268,  265,  263,  582,  473,  262,  473,
    1031       584,  261,  584,  240,  232,   85,  584,  475,   85,  475,
    1032       586,   87,  586,  205,  203,   85,  586,  478,  122,  478,
    1033       588,  117,  588,   87,  887,   70,  588,  480,   70,  480,
    1034       482,  887,  482,  887,  887,  887,  482,  590,  887,  590,
    1035 
    1036       887,  887,  887,  590,  484,  887,  484,  592,  887,  592,
    1037       887,  887,  887,  592,  486,  887,  486,  491,  887,  491,
    1038       887,  491,  887,  491,  382,  887,  382,  887,  887,  887,
    1039       382,  606,  887,  606,  887,  887,  887,  606,  503,  887,
    1040       503,  608,  887,  608,  887,  887,  887,  608,  505,  887,
    1041       505,  610,  887,  610,  887,  887,  887,  610,  507,  887,
    1042       507,  612,  887,  612,  887,  887,  887,  612,  509,  887,
    1043       509,  614,  887,  614,  887,  887,  887,  614,  511,  887,
    1044       511,  616,  887,  616,  887,  887,  887,  616,  513,  887,
    1045       513,   86,  887,  887,   86,  887,   86,   86,   86,   86,
    1046 
    1047        86,  669,  669,  669,  669,  669,  669,  669,  669,  669,
    1048       669,  669,  669,  669,  671,  887,  671,  887,  887,  887,
    1049       671,  578,  887,  578,  673,  887,  673,  887,  887,  887,
    1050       673,  580,  887,  580,  675,  887,  675,  887,  887,  887,
    1051       675,  582,  887,  582,  677,  887,  677,  887,  887,  887,
    1052       677,  584,  887,  584,  679,  887,  679,  887,  887,  887,
    1053       679,  586,  887,  586,  681,  887,  681,  887,  887,  887,
    1054       681,  588,  887,  588,  683,  887,  683,  887,  887,  887,
    1055       683,  590,  887,  590,   86,  887,   86,  887,  887,  887,
    1056        86,  592,  887,  592,  491,  887,  491,  887,  887,  887,
    1057 
    1058       491,  691,  887,  691,  887,  887,  887,  691,  606,  887,
    1059       606,  693,  887,  693,  887,  887,  887,  693,  608,  887,
    1060       608,  695,  887,  695,  887,  887,  887,  695,  610,  887,
    1061       610,  140,  887,  140,  887,  887,  887,  140,  612,  887,
    1062       612,  698,  887,  698,  614,  887,  614,   86,  887,  887,
    1063        86,  887,   86,   86,   86,   86,   86,  616,  887,  616,
    1064       669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
    1065       669,  669,  669,  737,  887,  737,  887,  887,  887,  737,
    1066       671,  887,  671,  204,  887,  204,  887,  887,  887,  204,
    1067       673,  887,  673,  740,  887,  740,  675,  887,  675,  204,
    1068 
    1069       887,  887,  204,  887,  204,  204,  204,  204,  204,  677,
    1070       887,  677,  741,  887,  741,  679,  887,  679,  681,  887,
    1071       681,  742,  887,  742,  683,  887,  683,   86,  887,   86,
    1072       744,  887,  744,  887,  887,  887,  744,  691,  887,  691,
    1073       269,  887,  269,  887,  887,  887,  269,  693,  887,  693,
    1074       747,  887,  747,  695,  887,  695,  140,  887,  140,  748,
    1075       887,  748,  887,  887,  887,  748,   86,  887,  887,   86,
    1076       887,   86,   86,   86,   86,   86,  781,  887,  781,  737,
    1077       887,  737,  204,  887,  204,  782,  887,  782,  887,  887,
    1078       887,  782,  784,  887,  784,  887,  887,  887,  784,  786,
    1079 
    1080       887,  786,  887,  887,  887,  786,  788,  887,  788,  789,
    1081       887,  789,  887,  887,  887,  789,  791,  887,  791,  887,
    1082       887,  887,  791,  812,  887,  812,  887,  887,  887,  812,
    1083       814,  887,  814,  887,  887,  887,  814,  816,  887,  816,
    1084       887,  887,  887,  816,  818,  887,  818,  887,  887,  887,
    1085       818,  820,  887,  820,  887,  887,  887,  820,  822,  887,
    1086       822,  887,  887,  887,  822,  616,  887,  616,  887,  887,
    1087       887,  616,  841,  887,  841,  887,  887,  887,  841,  677,
    1088       887,  677,  887,  887,  887,  677,  681,  887,  681,  887,
    1089       887,  887,  681,   86,  887,   86,  887,  887,  887,   86,
    1090 
    1091       846,  887,  846,  887,  887,  887,  846,  140,  887,  140,
    1092       887,  887,  887,  140,  204,  887,  204,  887,  887,  887,
    1093       204,   11,  887,  887,  887,  887,  887,  887,  887,  887,
    1094       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1095       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1096       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1097       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1098       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1099       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1100       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1101 
    1102       887,  887,  887,  887,  887,  887,  887
     1010      469,  680,  469,  678,  676,  674,  469,  471,  672,  471,
     1011      670,   87,   87,  471,  473,   87,  473,   87,   87,   87,
     1012      473,  348,   87,  348,  475,   87,  475,   87,   87,   87,
     1013      475,  350,  617,  350,  478,  615,  478,  613,  611,  609,
     1014      478,  354,  607,  354,  480,  502,  480,  605,  605,  594,
     1015
     1016      480,  356,  593,  356,  482,  591,  482,  483,  483,  589,
     1017      482,  358,  587,  358,  484,  585,  484,  583,  581,  579,
     1018      484,  365,   87,  365,  486,   87,  486,   87,   87,   87,
     1019      486,  367,   87,  367,  491,   87,  491,   87,  491,  514,
     1020      491,  380,  512,  380,  510,  380,  508,  380,  382,  382,
     1021      506,  382,  382,  382,  504,  382,  503,  490,  503,  487,
     1022      485,  361,  503,  505,  361,  505,  483,  481,  479,  505,
     1023      507,  476,  507,  474,  472,  470,  507,  392,   87,  392,
     1024      509,   87,  509,   87,  400,  399,  509,  394,  397,  394,
     1025      511,  395,  511,  393,  270,  265,  511,  396,  264,  396,
     1026
     1027      513,  389,  513,  389,  252,  379,  513,  398,  379,  398,
     1028       86,  240,  374,   86,  368,   86,   86,   86,   86,   86,
     1029      468,  468,  468,  468,  468,  468,  468,  468,  468,  468,
     1030      468,  468,  468,  578,  366,  578,  364,  360,  359,  578,
     1031      469,  357,  469,  580,  355,  580,  351,  349,  205,  580,
     1032      471,  201,  471,  582,   87,  582,  277,  276,  274,  582,
     1033      473,  270,  473,  584,  265,  584,  268,  265,  263,  584,
     1034      475,  262,  475,  586,  261,  586,  240,  232,   85,  586,
     1035      478,   85,  478,  588,   87,  588,  205,  203,   85,  588,
     1036      480,  122,  480,  482,  117,  482,   87,  891,   70,  482,
     1037
     1038      590,   70,  590,  891,  891,  891,  590,  484,  891,  484,
     1039      592,  891,  592,  891,  891,  891,  592,  486,  891,  486,
     1040      491,  891,  491,  891,  491,  891,  491,  382,  891,  382,
     1041      891,  891,  891,  382,  606,  891,  606,  891,  891,  891,
     1042      606,  503,  891,  503,  608,  891,  608,  891,  891,  891,
     1043      608,  505,  891,  505,  610,  891,  610,  891,  891,  891,
     1044      610,  507,  891,  507,  612,  891,  612,  891,  891,  891,
     1045      612,  509,  891,  509,  614,  891,  614,  891,  891,  891,
     1046      614,  511,  891,  511,  616,  891,  616,  891,  891,  891,
     1047      616,  513,  891,  513,   86,  891,  891,   86,  891,   86,
     1048
     1049       86,   86,   86,   86,  669,  669,  669,  669,  669,  669,
     1050      669,  669,  669,  669,  669,  669,  669,  671,  891,  671,
     1051      891,  891,  891,  671,  578,  891,  578,  673,  891,  673,
     1052      891,  891,  891,  673,  580,  891,  580,  675,  891,  675,
     1053      891,  891,  891,  675,  582,  891,  582,  677,  891,  677,
     1054      891,  891,  891,  677,  584,  891,  584,  679,  891,  679,
     1055      891,  891,  891,  679,  586,  891,  586,  681,  891,  681,
     1056      891,  891,  891,  681,  588,  891,  588,  683,  891,  683,
     1057      891,  891,  891,  683,  590,  891,  590,   86,  891,   86,
     1058      891,  891,  891,   86,  592,  891,  592,  491,  891,  491,
     1059
     1060      891,  891,  891,  491,  691,  891,  691,  891,  891,  891,
     1061      691,  606,  891,  606,  693,  891,  693,  891,  891,  891,
     1062      693,  608,  891,  608,  695,  891,  695,  891,  891,  891,
     1063      695,  610,  891,  610,  140,  891,  140,  891,  891,  891,
     1064      140,  612,  891,  612,  698,  891,  698,  614,  891,  614,
     1065       86,  891,  891,   86,  891,   86,   86,   86,   86,   86,
     1066      616,  891,  616,  669,  669,  669,  669,  669,  669,  669,
     1067      669,  669,  669,  669,  669,  669,  737,  891,  737,  891,
     1068      891,  891,  737,  671,  891,  671,  204,  891,  204,  891,
     1069      891,  891,  204,  673,  891,  673,  740,  891,  740,  675,
     1070
     1071      891,  675,  204,  891,  891,  204,  891,  204,  204,  204,
     1072      204,  204,  677,  891,  677,  741,  891,  741,  679,  891,
     1073      679,  681,  891,  681,  742,  891,  742,  683,  891,  683,
     1074       86,  891,   86,  744,  891,  744,  891,  891,  891,  744,
     1075      691,  891,  691,  269,  891,  269,  891,  891,  891,  269,
     1076      693,  891,  693,  747,  891,  747,  695,  891,  695,  140,
     1077      891,  140,  748,  891,  748,  891,  891,  891,  748,   86,
     1078      891,  891,   86,  891,   86,   86,   86,   86,   86,  782,
     1079      891,  782,  737,  891,  737,  204,  891,  204,  783,  891,
     1080      783,  891,  891,  891,  783,  785,  891,  785,  891,  891,
     1081
     1082      891,  785,  787,  891,  787,  891,  891,  891,  787,  789,
     1083      891,  789,  790,  891,  790,  891,  891,  891,  790,  792,
     1084      891,  792,  891,  891,  891,  792,  814,  891,  814,  891,
     1085      891,  891,  814,  816,  891,  816,  891,  891,  891,  816,
     1086      818,  891,  818,  891,  891,  891,  818,  820,  891,  820,
     1087      891,  891,  891,  820,  822,  891,  822,  891,  891,  891,
     1088      822,  824,  891,  824,  891,  891,  891,  824,  616,  891,
     1089      616,  891,  891,  891,  616,  844,  891,  844,  891,  891,
     1090      891,  844,  677,  891,  677,  891,  891,  891,  677,  681,
     1091      891,  681,  891,  891,  891,  681,   86,  891,   86,  891,
     1092
     1093      891,  891,   86,  849,  891,  849,  891,  891,  891,  849,
     1094      140,  891,  140,  891,  891,  891,  140,  204,  891,  204,
     1095      891,  891,  891,  204,   11,  891,  891,  891,  891,  891,
     1096      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1097      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1098      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1099      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1100      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1101      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1102      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1103
     1104      891,  891,  891,  891,  891,  891,  891,  891,  891,  891
    11031105    } ;
    11041106
    1105 static yyconst flex_int16_t yy_chk[2908] =
     1107static yyconst flex_int16_t yy_chk[2911] =
    11061108    {   0,
    11071109        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     
    11241126        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
    11251127        5,    5,    5,    5,    5,    5,    5,    5,    5,    7,
    1126         8,    9,   10,   37,   37,   20,   39,    9,   10,  886,
     1128        8,    9,   10,   37,   37,   20,   39,    9,   10,  890,
    11271129        7,    8,   13,   13,   13,   13,   13,   13,   15,   15,
    11281130
     
    11351137       47,   45,   45,   45,   49,   30,   30,   45,   45,   49,
    11361138       45,   30,   40,   45,   45,   40,   49,   30,   45,   56,
    1137        62,   45,   49,   30,   73,  885,  127,   53,  127,   51,
     1139       62,   45,   49,   30,   73,  889,  127,   53,  127,   51,
    11381140       61,   30,   62,   55,   30,   31,  108,   31,   31,   31,
    11391141
     
    11491151      164,   68,   68,   59,  113,   38,   68,  116,   38,  131,
    11501152
    1151       110,  131,   60,   67,   67,   67,   67,   67,   67,  877,
     1153      110,  131,   60,   67,   67,   67,   67,   67,   67,  881,
    11521154      142,   67,   68,   68,   68,   68,   68,   68,   80,   80,
    11531155       80,   80,   80,   80,  153,   38,   38,   77,   77,  134,
    11541156      110,  134,   77,  153,   77,  110,  135,  135,  135,   77,
    1155        82,   82,   82,   82,   82,   82,  876,  243,   77,   77,
     1157       82,   82,   82,   82,   82,   82,  880,  243,   77,   77,
    11561158       77,   77,   83,   83,   83,   83,   83,   83,  110,   77,
    11571159      103,  103,  103,  103,  103,  103,  104,  104,  104,  104,
     
    11631165       85,  166,  159,  150,   85,   85,  161,   85,  160,   85,
    11641166      145,  162,  104,  167,  168,  161,  169,  163,   85,   85,
    1165        85,  105,  163,  105,  105,  105,  105,  105,  105,  873,
     1167       85,  105,  163,  105,  105,  105,  105,  105,  105,  877,
    11661168      160,  171,  162,  162,  165,  163,  167,  169,  173,   85,
    11671169      105,  106,   85,  106,  165,  172,  106,  106,  106,  106,
     
    11761178      189,  158,  158,  188,  192,  158,  194,  158,  284,  219,
    11771179      185,  219,  158,  158,  158,  193,  158,  192,  220,  194,
    1178       220,  191,  198,  198,  191,  192,  205,  198,  193,  872,
     1180      220,  191,  198,  198,  191,  192,  205,  198,  193,  876,
    11791181      193,  197,  197,  197,  197,  197,  197,  200,  200,  197,
    11801182      248,  221,  200,  198,  198,  198,  198,  198,  198,  202,
     
    11931195      245,  245,  270,  288,  293,  286,  294,  300,  306,  293,
    11941196
    1195       308,  244,  300,  306,  870,  294,  308,  244,  246,  246,
     1197      308,  244,  300,  306,  874,  294,  308,  244,  246,  246,
    11961198      246,  246,  246,  246,  253,  286,  288,  255,  255,  255,
    11971199      255,  255,  255,  287,  246,  247,  246,  247,  246,  246,
    11981200      247,  247,  247,  247,  247,  247,  290,  253,  287,  253,
    1199       869,  246,  289,  253,  287,  287,  246,  292,  246,  253,
     1201      873,  246,  289,  253,  287,  287,  246,  292,  246,  253,
    12001202      255,  246,  291,  246,  260,  260,  260,  260,  260,  260,
    12011203      289,  253,  290,  292,  292,  253,  295,  291,  296,  253,
     
    12091211      335,  324,  337,  339,  340,  326,  329,  328,  401,  327,
    12101212      331,  337,  334,  335,  341,  343,  332,  340,  342,  401,
    1211       333,  339,  341,  342,  344,  344,  345,  460,  862,  344,
     1213      333,  339,  341,  342,  344,  344,  345,  460,  866,  344,
    12121214      343,  344,  345,  352,  352,  352,  352,  353,  353,  353,
    12131215      353,  362,  363,  362,  363,  370,  370,  370,  370,  370,
    12141216      370,  372,  460,  372,  380,  381,  372,  372,  372,  372,
    1215       372,  372,  861,  402,  380,  381,  352,  371,  371,  371,
     1217      372,  372,  865,  402,  380,  381,  352,  371,  371,  371,
    12161218
    12171219      371,  371,  371,  374,  374,  374,  374,  374,  374,  402,
    1218       380,  381,  403,  371,  404,  371,  860,  371,  371,  375,
     1220      380,  381,  403,  371,  404,  371,  864,  371,  371,  375,
    12191221      375,  375,  375,  375,  375,  383,  382,  403,  406,  405,
    12201222      371,  383,  407,  404,  408,  371,  374,  371,  405,  406,
     
    12331235      450,  453,  442,  444,  455,  456,  447,  457,  458,  449,
    12341236      459,  461,  463,  455,  451,  458,  454,  459,  462,  452,
    1235       457,  453,  466,  456,  464,  467,  462,  525,  859,  463,
     1237      457,  453,  466,  456,  464,  467,  462,  525,  863,  463,
    12361238      525,  468,  491,  461,  467,  464,  462,  468,  477,  477,
    12371239      477,  477,  491,  515,  466,  488,  488,  488,  488,  488,
     
    12391241      488,  490,  490,  490,  490,  490,  490,  519,  491,  521,
    12401242      515,  488,  492,  488,  492,  488,  488,  492,  492,  492,
    1241       492,  492,  492,  494,  516,  495,  493,  519,  488,  855,
    1242       851,  521,  518,  488,  490,  488,  493,  516,  488,  529,
     1243      492,  492,  492,  494,  516,  495,  493,  519,  488,  862,
     1244      858,  521,  518,  488,  490,  488,  493,  516,  488,  529,
    12431245      488,  497,  497,  497,  497,  497,  497,  518,  520,  494,
    12441246      492,  495,  493,  498,  498,  498,  498,  498,  498,  523,
    1245       529,  520,  526,  848,  523,  847,  528,  846,  522,  498,
     1247      529,  520,  526,  854,  523,  851,  528,  850,  522,  498,
    12461248      499,  498,  499,  498,  498,  499,  499,  499,  499,  499,
    12471249      499,  522,  526,  524,  527,  528,  498,  531,  530,  532,
     
    12501252      532,  535,  537,  533,  536,  538,  539,  541,  542,  547,
    12511253      535,  539,  544,  541,  538,  545,  546,  542,  547,  537,
    1252       550,  551,  845,  549,  534,  552,  536,  554,  560,  544,
     1254      550,  551,  849,  549,  534,  552,  536,  554,  560,  544,
    12531255      545,  546,  549,  551,  555,  557,  558,  550,  561,  555,
    12541256      552,  562,  554,  565,  557,  558,  564,  567,  566,  568,
    12551257      560,  561,  575,  565,  564,  566,  569,  571,  562,  574,
    12561258      572,  568,  569,  620,  619,  575,  571,  601,  601,  567,
    1257       572,  619,  620,  844,  843,  622,  574,  594,  594,  594,
     1259      572,  619,  620,  848,  847,  622,  574,  594,  594,  594,
    12581260      594,  594,  594,  595,  595,  595,  595,  595,  595,  597,
    12591261      601,  597,  622,  621,  597,  597,  597,  597,  597,  597,
    12601262
    1261       600,  600,  600,  600,  600,  600,  621,  602,  626,  842,
     1263      600,  600,  600,  600,  600,  600,  621,  602,  626,  846,
    12621264      594,  596,  596,  596,  596,  596,  596,  603,  618,  603,
    12631265      623,  624,  603,  618,  628,  626,  625,  596,  624,  596,
     
    12681270      633,  646,  639,  637,  650,  642,  651,  656,  640,  638,
    12691271      646,  653,  657,  636,  644,  665,  656,  641,  664,  657,
    1270       645,  667,  668,  841,  650,  665,  700,  664,  653,  699,
    1271 
    1272       667,  702,  705,  651,  714,  837,  700,  668,  686,  686,
     1272      645,  667,  668,  842,  650,  665,  700,  664,  653,  699,
     1273
     1274      667,  702,  705,  651,  714,  842,  700,  668,  686,  686,
    12731275      686,  686,  686,  686,  690,  690,  690,  690,  690,  690,
    12741276      699,  708,  705,  703,  686,  714,  686,  702,  686,  686,
     
    12761278      712,  686,  711,  717,  710,  718,  686,  690,  686,  712,
    12771279      720,  686,  717,  686,  713,  711,  716,  713,  719,  716,
    1278       721,  719,  715,  720,  722,  723,  724,  725,  721,  728,
    1279       731,  718,  732,  735,  722,  733,  725,  736,  723,  756,
    1280       757,  735,  836,  754,  756,  759,  736,  724,  755,  760,
    1281       731,  761,  728,  764,  732,  757,  733,  743,  743,  743,
    1282 
    1283       743,  743,  743,  754,  758,  755,  760,  762,  759,  763,
    1284       762,  769,  766,  768,  758,  766,  768,  761,  769,  772,
    1285       770,  764,  763,  770,  771,  773,  778,  771,  793,  795,
    1286       743,  798,  797,  796,  772,  797,  799,  800,  802,  799,
    1287       800,  803,  804,  806,  807,  804,  810,  807,  773,  778,
    1288       795,  796,  809,  798,  808,  793,  802,  808,  811,  826,
    1289       830,  809,  810,  827,  829,  806,  828,  803,  831,  828,
    1290       827,  831,  832,  829,  811,  834,  835,  839,  830,  835,
    1291       826,  840,  838,  849,  830,  838,  839,  853,  850,  832,
    1292       840,  852,  849,  850,  852,  854,  856,  853,  857,  856,
    1293 
    1294       854,  857,  858,  863,  864,  858,  865,  866,  867,  865,
    1295       868,  867,  871,  868,  874,  875,  878,  866,  879,  864,
    1296       880,  882,  881,  863,  883,  878,  884,  833,  825,  824,
    1297       875,  879,  823,  822,  871,  874,  884,  821,  820,  882,
    1298       819,  818,  880,  881,  817,  816,  883,  888,  888,  888,
    1299       888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
    1300       889,  889,  889,  889,  889,  889,  889,  889,  889,  889,
    1301       889,  889,  889,  890,  890,  890,  890,  890,  890,  890,
    1302       890,  890,  890,  890,  890,  890,  891,  815,  814,  891,
    1303       813,  891,  891,  891,  891,  891,  892,  812,  805,  801,
    1304 
    1305       892,  892,  892,  892,  892,  892,  893,  893,  893,  893,
    1306       893,  893,  893,  893,  893,  893,  893,  893,  893,  894,
    1307       794,  792,  894,  791,  894,  894,  894,  894,  894,  895,
    1308       790,  895,  895,  789,  895,  895,  895,  895,  895,  895,
    1309       788,  895,  896,  787,  786,  896,  896,  896,  896,  896,
    1310       896,  896,  896,  785,  896,  897,  897,  897,  897,  897,
    1311       897,  897,  897,  897,  897,  897,  897,  897,  898,  898,
    1312       784,  898,  783,  782,  781,  898,  899,  780,  779,  899,
    1313       777,  899,  899,  899,  899,  899,  900,  776,  900,  775,
    1314       774,  767,  900,  901,  765,  901,  753,  752,  751,  901,
    1315 
    1316       902,  750,  902,  749,  748,  747,  902,  903,  746,  903,
    1317       745,  742,  741,  903,  904,  740,  904,  734,  730,  729,
    1318       904,  905,  727,  905,  726,  709,  701,  905,  906,  698,
    1319       906,  693,  691,  687,  906,  907,  677,  907,  673,  671,
    1320       669,  907,  908,  666,  908,  663,  662,  661,  908,  909,
    1321       909,  909,  909,  909,  909,  909,  909,  909,  909,  909,
    1322       909,  909,  910,  660,  910,  911,  911,  659,  911,  911,
    1323       911,  658,  911,  912,  912,  655,  912,  913,  654,  913,
    1324       652,  649,  648,  913,  914,  647,  914,  643,  616,  612,
    1325       914,  915,  610,  915,  608,  606,  604,  915,  916,  598,
    1326 
    1327       916,  917,  592,  917,  590,  588,  586,  917,  918,  584,
    1328       918,  919,  582,  580,  919,  578,  919,  919,  919,  919,
    1329       919,  920,  920,  920,  920,  920,  920,  920,  920,  920,
    1330       920,  920,  920,  920,  921,  921,  921,  921,  921,  921,
    1331       921,  921,  921,  921,  921,  921,  921,  922,  577,  922,
    1332       576,  573,  570,  922,  923,  563,  923,  559,  556,  553,
    1333       923,  924,  548,  924,  543,  540,  517,  924,  925,  513,
    1334       925,  926,  511,  926,  509,  507,  505,  926,  927,  503,
    1335       927,  928,  502,  928,  501,  500,  489,  928,  929,  486,
    1336       929,  930,  484,  930,  483,  482,  480,  930,  931,  478,
    1337 
    1338       931,  932,  475,  932,  473,  471,  469,  932,  933,  465,
    1339       933,  934,  448,  934,  446,  438,  436,  934,  935,  428,
    1340       935,  936,  426,  936,  424,  398,  396,  936,  937,  394,
    1341       937,  938,  392,  938,  391,  938,  390,  938,  939,  377,
    1342       939,  367,  939,  365,  939,  940,  940,  364,  940,  940,
    1343       940,  360,  940,  941,  358,  941,  356,  354,  350,  941,
    1344       942,  348,  942,  347,  346,  336,  942,  943,  321,  943,
    1345       298,  277,  275,  943,  944,  273,  944,  945,  272,  945,
    1346       271,  269,  268,  945,  946,  263,  946,  947,  259,  947,
    1347       258,  254,  251,  947,  948,  250,  948,  949,  239,  949,
    1348 
    1349       238,  231,  230,  949,  950,  227,  950,  951,  217,  215,
    1350       951,  214,  951,  951,  951,  951,  951,  952,  952,  952,
    1351       952,  952,  952,  952,  952,  952,  952,  952,  952,  952,
    1352       953,  213,  953,  207,  206,  204,  953,  954,  199,  954,
    1353       955,  178,  955,  149,  147,  146,  955,  956,  140,  956,
    1354       957,  138,  957,  136,  128,  125,  957,  958,  124,  958,
    1355       959,  120,  959,  101,   98,   95,  959,  960,   93,  960,
    1356       961,   86,  961,   72,   70,   66,  961,  962,   36,  962,
    1357       963,   33,  963,   18,   11,    4,  963,  964,    3,  964,
    1358       965,    0,  965,    0,    0,    0,  965,  966,    0,  966,
    1359 
    1360         0,    0,    0,  966,  967,    0,  967,  968,    0,  968,
    1361         0,    0,    0,  968,  969,    0,  969,  970,    0,  970,
    1362         0,  970,    0,  970,  971,    0,  971,    0,    0,    0,
    1363       971,  972,    0,  972,    0,    0,    0,  972,  973,    0,
    1364       973,  974,    0,  974,    0,    0,    0,  974,  975,    0,
    1365       975,  976,    0,  976,    0,    0,    0,  976,  977,    0,
    1366       977,  978,    0,  978,    0,    0,    0,  978,  979,    0,
    1367       979,  980,    0,  980,    0,    0,    0,  980,  981,    0,
    1368       981,  982,    0,  982,    0,    0,    0,  982,  983,    0,
    1369       983,  984,    0,    0,  984,    0,  984,  984,  984,  984,
    1370 
    1371       984,  985,  985,  985,  985,  985,  985,  985,  985,  985,
    1372       985,  985,  985,  985,  986,    0,  986,    0,    0,    0,
    1373       986,  987,    0,  987,  988,    0,  988,    0,    0,    0,
    1374       988,  989,    0,  989,  990,    0,  990,    0,    0,    0,
    1375       990,  991,    0,  991,  992,    0,  992,    0,    0,    0,
    1376       992,  993,    0,  993,  994,    0,  994,    0,    0,    0,
    1377       994,  995,    0,  995,  996,    0,  996,    0,    0,    0,
    1378       996,  997,    0,  997,  998,    0,  998,    0,    0,    0,
    1379       998,  999,    0,  999, 1000,    0, 1000,    0,    0,    0,
    1380      1000, 1001,    0, 1001, 1002,    0, 1002,    0,    0,    0,
    1381 
    1382      1002, 1003,    0, 1003,    0,    0,    0, 1003, 1004,    0,
    1383      1004, 1005,    0, 1005,    0,    0,    0, 1005, 1006,    0,
    1384      1006, 1007,    0, 1007,    0,    0,    0, 1007, 1008,    0,
    1385      1008, 1009,    0, 1009,    0,    0,    0, 1009, 1010,    0,
    1386      1010, 1011,    0, 1011, 1012,    0, 1012, 1013,    0,    0,
    1387      1013,    0, 1013, 1013, 1013, 1013, 1013, 1014,    0, 1014,
    1388      1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
    1389      1015, 1015, 1015, 1016,    0, 1016,    0,    0,    0, 1016,
    1390      1017,    0, 1017, 1018,    0, 1018,    0,    0,    0, 1018,
    1391      1019,    0, 1019, 1020,    0, 1020, 1021,    0, 1021, 1022,
    1392 
    1393         0,    0, 1022,    0, 1022, 1022, 1022, 1022, 1022, 1023,
    1394         0, 1023, 1024,    0, 1024, 1025,    0, 1025, 1026,    0,
    1395      1026, 1027,    0, 1027, 1028,    0, 1028, 1029,    0, 1029,
    1396      1030,    0, 1030,    0,    0,    0, 1030, 1031,    0, 1031,
    1397      1032,    0, 1032,    0,    0,    0, 1032, 1033,    0, 1033,
    1398      1034,    0, 1034, 1035,    0, 1035, 1036,    0, 1036, 1037,
    1399         0, 1037,    0,    0,    0, 1037, 1038,    0,    0, 1038,
    1400         0, 1038, 1038, 1038, 1038, 1038, 1039,    0, 1039, 1040,
    1401         0, 1040, 1041,    0, 1041, 1042,    0, 1042,    0,    0,
    1402         0, 1042, 1043,    0, 1043,    0,    0,    0, 1043, 1044,
    1403 
    1404         0, 1044,    0,    0,    0, 1044, 1045,    0, 1045, 1046,
    1405         0, 1046,    0,    0,    0, 1046, 1047,    0, 1047,    0,
    1406         0,    0, 1047, 1048,    0, 1048,    0,    0,    0, 1048,
    1407      1049,    0, 1049,    0,    0,    0, 1049, 1050,    0, 1050,
    1408         0,    0,    0, 1050, 1051,    0, 1051,    0,    0,    0,
    1409      1051, 1052,    0, 1052,    0,    0,    0, 1052, 1053,    0,
    1410      1053,    0,    0,    0, 1053, 1054,    0, 1054,    0,    0,
    1411         0, 1054, 1055,    0, 1055,    0,    0,    0, 1055, 1056,
    1412         0, 1056,    0,    0,    0, 1056, 1057,    0, 1057,    0,
    1413         0,    0, 1057, 1058,    0, 1058,    0,    0,    0, 1058,
    1414 
    1415      1059,    0, 1059,    0,    0,    0, 1059, 1060,    0, 1060,
    1416         0,    0,    0, 1060, 1061,    0, 1061,    0,    0,    0,
    1417      1061,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1418       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1419       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1420       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1421       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1422       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1423       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1424       887,  887,  887,  887,  887,  887,  887,  887,  887,  887,
    1425 
    1426       887,  887,  887,  887,  887,  887,  887
     1280      721,  719,  715,  720,  722,  723,  724,  725,  721,  731,
     1281      728,  718,  732,  735,  722,  733,  725,  736,  723,  756,
     1282      757,  735,  758,  754,  756,  759,  736,  724,  728,  731,
     1283      755,  761,  758,  728,  732,  757,  733,  743,  743,  743,
     1284
     1285      743,  743,  743,  754,  760,  763,  762,  755,  759,  762,
     1286      764,  766,  768,  769,  766,  768,  770,  761,  763,  770,
     1287      769,  760,  771,  773,  772,  771,  775,  779,  794,  797,
     1288      743,  796,  798,  800,  799,  798,  800,  801,  764,  772,
     1289      801,  803,  804,  807,  810,  805,  773,  797,  805,  775,
     1290      779,  808,  796,  810,  808,  794,  799,  809,  811,  803,
     1291      809,  812,  813,  828,  829,  807,  830,  831,  804,  830,
     1292      832,  829,  812,  834,  811,  856,  831,  833,  813,  837,
     1293      833,  875,  837,  840,  828,  856,  840,  841,  832,  843,
     1294      834,  852,  853,  867,  832,  868,  841,  853,  843,  855,
     1295
     1296      852,  857,  855,  875,  859,  860,  857,  859,  860,  861,
     1297      868,  869,  861,  867,  869,  870,  871,  872,  878,  871,
     1298      872,  879,  882,  884,  883,  870,  885,  887,  886,  845,
     1299      888,  882,  844,  839,  838,  836,  879,  883,  835,  878,
     1300      888,  827,  826,  825,  824,  884,  886,  885,  823,  887,
     1301      892,  892,  892,  892,  892,  892,  892,  892,  892,  892,
     1302      892,  892,  892,  893,  893,  893,  893,  893,  893,  893,
     1303      893,  893,  893,  893,  893,  893,  894,  894,  894,  894,
     1304      894,  894,  894,  894,  894,  894,  894,  894,  894,  895,
     1305      822,  821,  895,  820,  895,  895,  895,  895,  895,  896,
     1306
     1307      819,  818,  817,  896,  896,  896,  896,  896,  896,  897,
     1308      897,  897,  897,  897,  897,  897,  897,  897,  897,  897,
     1309      897,  897,  898,  816,  815,  898,  814,  898,  898,  898,
     1310      898,  898,  899,  806,  899,  899,  802,  899,  899,  899,
     1311      899,  899,  899,  795,  899,  900,  793,  792,  900,  900,
     1312      900,  900,  900,  900,  900,  900,  791,  900,  901,  901,
     1313      901,  901,  901,  901,  901,  901,  901,  901,  901,  901,
     1314      901,  902,  902,  790,  902,  789,  788,  787,  902,  903,
     1315      786,  785,  903,  784,  903,  903,  903,  903,  903,  904,
     1316      783,  904,  782,  781,  780,  904,  905,  778,  905,  777,
     1317
     1318      776,  774,  905,  906,  767,  906,  765,  753,  752,  906,
     1319      907,  751,  907,  750,  749,  748,  907,  908,  747,  908,
     1320      746,  745,  742,  908,  909,  741,  909,  740,  734,  730,
     1321      909,  910,  729,  910,  727,  726,  709,  910,  911,  701,
     1322      911,  698,  693,  691,  911,  912,  687,  912,  677,  673,
     1323      671,  912,  913,  913,  913,  913,  913,  913,  913,  913,
     1324      913,  913,  913,  913,  913,  914,  669,  914,  915,  915,
     1325      666,  915,  915,  915,  663,  915,  916,  916,  662,  916,
     1326      917,  661,  917,  660,  659,  658,  917,  918,  655,  918,
     1327      654,  652,  649,  918,  919,  648,  919,  647,  643,  616,
     1328
     1329      919,  920,  612,  920,  921,  610,  921,  608,  606,  604,
     1330      921,  922,  598,  922,  923,  592,  590,  923,  588,  923,
     1331      923,  923,  923,  923,  924,  924,  924,  924,  924,  924,
     1332      924,  924,  924,  924,  924,  924,  924,  925,  925,  925,
     1333      925,  925,  925,  925,  925,  925,  925,  925,  925,  925,
     1334      926,  586,  926,  584,  582,  580,  926,  927,  578,  927,
     1335      577,  576,  573,  927,  928,  570,  928,  563,  559,  556,
     1336      928,  929,  553,  929,  930,  548,  930,  543,  540,  517,
     1337      930,  931,  513,  931,  932,  511,  932,  509,  507,  505,
     1338      932,  933,  503,  933,  934,  502,  934,  501,  500,  489,
     1339
     1340      934,  935,  486,  935,  936,  484,  936,  483,  482,  480,
     1341      936,  937,  478,  937,  938,  475,  938,  473,  471,  469,
     1342      938,  939,  465,  939,  940,  448,  940,  446,  438,  436,
     1343      940,  941,  428,  941,  942,  426,  942,  424,  942,  398,
     1344      942,  943,  396,  943,  394,  943,  392,  943,  944,  944,
     1345      391,  944,  944,  944,  390,  944,  945,  377,  945,  367,
     1346      365,  364,  945,  946,  360,  946,  358,  356,  354,  946,
     1347      947,  350,  947,  348,  347,  346,  947,  948,  336,  948,
     1348      949,  321,  949,  298,  277,  275,  949,  950,  273,  950,
     1349      951,  272,  951,  271,  269,  268,  951,  952,  263,  952,
     1350
     1351      953,  259,  953,  258,  254,  251,  953,  954,  250,  954,
     1352      955,  239,  238,  955,  231,  955,  955,  955,  955,  955,
     1353      956,  956,  956,  956,  956,  956,  956,  956,  956,  956,
     1354      956,  956,  956,  957,  230,  957,  227,  217,  215,  957,
     1355      958,  214,  958,  959,  213,  959,  207,  206,  204,  959,
     1356      960,  199,  960,  961,  178,  961,  149,  147,  146,  961,
     1357      962,  140,  962,  963,  138,  963,  136,  128,  125,  963,
     1358      964,  124,  964,  965,  120,  965,  101,   98,   95,  965,
     1359      966,   93,  966,  967,   86,  967,   72,   70,   66,  967,
     1360      968,   36,  968,  969,   33,  969,   18,   11,    4,  969,
     1361
     1362      970,    3,  970,    0,    0,    0,  970,  971,    0,  971,
     1363      972,    0,  972,    0,    0,    0,  972,  973,    0,  973,
     1364      974,    0,  974,    0,  974,    0,  974,  975,    0,  975,
     1365        0,    0,    0,  975,  976,    0,  976,    0,    0,    0,
     1366      976,  977,    0,  977,  978,    0,  978,    0,    0,    0,
     1367      978,  979,    0,  979,  980,    0,  980,    0,    0,    0,
     1368      980,  981,    0,  981,  982,    0,  982,    0,    0,    0,
     1369      982,  983,    0,  983,  984,    0,  984,    0,    0,    0,
     1370      984,  985,    0,  985,  986,    0,  986,    0,    0,    0,
     1371      986,  987,    0,  987,  988,    0,    0,  988,    0,  988,
     1372
     1373      988,  988,  988,  988,  989,  989,  989,  989,  989,  989,
     1374      989,  989,  989,  989,  989,  989,  989,  990,    0,  990,
     1375        0,    0,    0,  990,  991,    0,  991,  992,    0,  992,
     1376        0,    0,    0,  992,  993,    0,  993,  994,    0,  994,
     1377        0,    0,    0,  994,  995,    0,  995,  996,    0,  996,
     1378        0,    0,    0,  996,  997,    0,  997,  998,    0,  998,
     1379        0,    0,    0,  998,  999,    0,  999, 1000,    0, 1000,
     1380        0,    0,    0, 1000, 1001,    0, 1001, 1002,    0, 1002,
     1381        0,    0,    0, 1002, 1003,    0, 1003, 1004,    0, 1004,
     1382        0,    0,    0, 1004, 1005,    0, 1005, 1006,    0, 1006,
     1383
     1384        0,    0,    0, 1006, 1007,    0, 1007,    0,    0,    0,
     1385     1007, 1008,    0, 1008, 1009,    0, 1009,    0,    0,    0,
     1386     1009, 1010,    0, 1010, 1011,    0, 1011,    0,    0,    0,
     1387     1011, 1012,    0, 1012, 1013,    0, 1013,    0,    0,    0,
     1388     1013, 1014,    0, 1014, 1015,    0, 1015, 1016,    0, 1016,
     1389     1017,    0,    0, 1017,    0, 1017, 1017, 1017, 1017, 1017,
     1390     1018,    0, 1018, 1019, 1019, 1019, 1019, 1019, 1019, 1019,
     1391     1019, 1019, 1019, 1019, 1019, 1019, 1020,    0, 1020,    0,
     1392        0,    0, 1020, 1021,    0, 1021, 1022,    0, 1022,    0,
     1393        0,    0, 1022, 1023,    0, 1023, 1024,    0, 1024, 1025,
     1394
     1395        0, 1025, 1026,    0,    0, 1026,    0, 1026, 1026, 1026,
     1396     1026, 1026, 1027,    0, 1027, 1028,    0, 1028, 1029,    0,
     1397     1029, 1030,    0, 1030, 1031,    0, 1031, 1032,    0, 1032,
     1398     1033,    0, 1033, 1034,    0, 1034,    0,    0,    0, 1034,
     1399     1035,    0, 1035, 1036,    0, 1036,    0,    0,    0, 1036,
     1400     1037,    0, 1037, 1038,    0, 1038, 1039,    0, 1039, 1040,
     1401        0, 1040, 1041,    0, 1041,    0,    0,    0, 1041, 1042,
     1402        0,    0, 1042,    0, 1042, 1042, 1042, 1042, 1042, 1043,
     1403        0, 1043, 1044,    0, 1044, 1045,    0, 1045, 1046,    0,
     1404     1046,    0,    0,    0, 1046, 1047,    0, 1047,    0,    0,
     1405
     1406        0, 1047, 1048,    0, 1048,    0,    0,    0, 1048, 1049,
     1407        0, 1049, 1050,    0, 1050,    0,    0,    0, 1050, 1051,
     1408        0, 1051,    0,    0,    0, 1051, 1052,    0, 1052,    0,
     1409        0,    0, 1052, 1053,    0, 1053,    0,    0,    0, 1053,
     1410     1054,    0, 1054,    0,    0,    0, 1054, 1055,    0, 1055,
     1411        0,    0,    0, 1055, 1056,    0, 1056,    0,    0,    0,
     1412     1056, 1057,    0, 1057,    0,    0,    0, 1057, 1058,    0,
     1413     1058,    0,    0,    0, 1058, 1059,    0, 1059,    0,    0,
     1414        0, 1059, 1060,    0, 1060,    0,    0,    0, 1060, 1061,
     1415        0, 1061,    0,    0,    0, 1061, 1062,    0, 1062,    0,
     1416
     1417        0,    0, 1062, 1063,    0, 1063,    0,    0,    0, 1063,
     1418     1064,    0, 1064,    0,    0,    0, 1064, 1065,    0, 1065,
     1419        0,    0,    0, 1065,  891,  891,  891,  891,  891,  891,
     1420      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1421      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1422      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1423      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1424      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1425      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1426      891,  891,  891,  891,  891,  891,  891,  891,  891,  891,
     1427
     1428      891,  891,  891,  891,  891,  891,  891,  891,  891,  891
    14271429    } ;
    14281430
    14291431/* Table of booleans, true if rule could match eol. */
    1430 static yyconst flex_int32_t yy_rule_can_match_eol[181] =
     1432static yyconst flex_int32_t yy_rule_can_match_eol[182] =
    14311433    {   0,
    143214341, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     
    14351437    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14361438    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1437     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1,
    1438     0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1439    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
     1440    1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14391441    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    14401442    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1441     0,     };
     1443    0, 0,     };
    14421444
    14431445static yy_state_type yy_last_accepting_state;
     
    14661468 * Author           : Peter A. Buhr
    14671469 * Created On       : Sat Sep 22 08:58:10 2001
    1468  * Last Modified By : Peter A. Buhr
    1469  * Last Modified On : Thu Jun 23 07:29:30 2016
    1470  * Update Count     : 457
     1470 * Last Modified By :
     1471 * Last Modified On : Sun Jul 31 07:19:36 2016
     1472 * Update Count     : 459
    14711473 */
    14721474#line 20 "lex.ll"
     
    15291531
    15301532
    1531 #line 1532 "Parser/lex.cc"
     1533#line 1534 "Parser/lex.cc"
    15321534
    15331535#define INITIAL 0
     
    17241726
    17251727                                   /* line directives */
    1726 #line 1727 "Parser/lex.cc"
     1728#line 1729 "Parser/lex.cc"
    17271729
    17281730        if ( !(yy_init) )
     
    17781780                                {
    17791781                                yy_current_state = (int) yy_def[yy_current_state];
    1780                                 if ( yy_current_state >= 888 )
     1782                                if ( yy_current_state >= 892 )
    17811783                                        yy_c = yy_meta[(unsigned int) yy_c];
    17821784                                }
     
    17841786                        ++yy_cp;
    17851787                        }
    1786                 while ( yy_base[yy_current_state] != 2822 );
     1788                while ( yy_base[yy_current_state] != 2825 );
    17871789
    17881790yy_find_action:
     
    20812083YY_RULE_SETUP
    20822084#line 216 "lex.ll"
     2085{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
     2086        YY_BREAK
     2087case 48:
     2088YY_RULE_SETUP
     2089#line 217 "lex.ll"
    20832090{ KEYWORD_RETURN(FINALLY); }                    // CFA
    20842091        YY_BREAK
    2085 case 48:
    2086 YY_RULE_SETUP
    2087 #line 217 "lex.ll"
     2092case 49:
     2093YY_RULE_SETUP
     2094#line 218 "lex.ll"
    20882095{ KEYWORD_RETURN(FLOAT); }
    20892096        YY_BREAK
    2090 case 49:
    2091 YY_RULE_SETUP
    2092 #line 218 "lex.ll"
     2097case 50:
     2098YY_RULE_SETUP
     2099#line 219 "lex.ll"
    20932100{ KEYWORD_RETURN(FLOAT); }                              // GCC
    20942101        YY_BREAK
    2095 case 50:
    2096 YY_RULE_SETUP
    2097 #line 219 "lex.ll"
     2102case 51:
     2103YY_RULE_SETUP
     2104#line 220 "lex.ll"
    20982105{ KEYWORD_RETURN(FOR); }
    20992106        YY_BREAK
    2100 case 51:
    2101 YY_RULE_SETUP
    2102 #line 220 "lex.ll"
     2107case 52:
     2108YY_RULE_SETUP
     2109#line 221 "lex.ll"
    21032110{ KEYWORD_RETURN(FORALL); }                             // CFA
    21042111        YY_BREAK
    2105 case 52:
    2106 YY_RULE_SETUP
    2107 #line 221 "lex.ll"
     2112case 53:
     2113YY_RULE_SETUP
     2114#line 222 "lex.ll"
    21082115{ KEYWORD_RETURN(FORTRAN); }
    21092116        YY_BREAK
    2110 case 53:
    2111 YY_RULE_SETUP
    2112 #line 222 "lex.ll"
     2117case 54:
     2118YY_RULE_SETUP
     2119#line 223 "lex.ll"
    21132120{ KEYWORD_RETURN(FTYPE); }                              // CFA
    21142121        YY_BREAK
    2115 case 54:
    2116 YY_RULE_SETUP
    2117 #line 223 "lex.ll"
     2122case 55:
     2123YY_RULE_SETUP
     2124#line 224 "lex.ll"
    21182125{ KEYWORD_RETURN(GENERIC); }                    // C11
    21192126        YY_BREAK
    2120 case 55:
    2121 YY_RULE_SETUP
    2122 #line 224 "lex.ll"
     2127case 56:
     2128YY_RULE_SETUP
     2129#line 225 "lex.ll"
    21232130{ KEYWORD_RETURN(GOTO); }
    21242131        YY_BREAK
    2125 case 56:
    2126 YY_RULE_SETUP
    2127 #line 225 "lex.ll"
     2132case 57:
     2133YY_RULE_SETUP
     2134#line 226 "lex.ll"
    21282135{ KEYWORD_RETURN(IF); }
    21292136        YY_BREAK
    2130 case 57:
    2131 YY_RULE_SETUP
    2132 #line 226 "lex.ll"
     2137case 58:
     2138YY_RULE_SETUP
     2139#line 227 "lex.ll"
    21332140{ KEYWORD_RETURN(IMAGINARY); }                  // C99
    2134         YY_BREAK
    2135 case 58:
    2136 YY_RULE_SETUP
    2137 #line 227 "lex.ll"
    2138 { KEYWORD_RETURN(IMAGINARY); }                  // GCC
    21392141        YY_BREAK
    21402142case 59:
     
    21462148YY_RULE_SETUP
    21472149#line 229 "lex.ll"
     2150{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
     2151        YY_BREAK
     2152case 61:
     2153YY_RULE_SETUP
     2154#line 230 "lex.ll"
    21482155{ KEYWORD_RETURN(INLINE); }                             // C99
    2149         YY_BREAK
    2150 case 61:
    2151 YY_RULE_SETUP
    2152 #line 230 "lex.ll"
    2153 { KEYWORD_RETURN(INLINE); }                             // GCC
    21542156        YY_BREAK
    21552157case 62:
     
    21612163YY_RULE_SETUP
    21622164#line 232 "lex.ll"
     2165{ KEYWORD_RETURN(INLINE); }                             // GCC
     2166        YY_BREAK
     2167case 64:
     2168YY_RULE_SETUP
     2169#line 233 "lex.ll"
    21632170{ KEYWORD_RETURN(INT); }
    21642171        YY_BREAK
    2165 case 64:
    2166 YY_RULE_SETUP
    2167 #line 233 "lex.ll"
     2172case 65:
     2173YY_RULE_SETUP
     2174#line 234 "lex.ll"
    21682175{ KEYWORD_RETURN(INT); }                                // GCC
    21692176        YY_BREAK
    2170 case 65:
    2171 YY_RULE_SETUP
    2172 #line 234 "lex.ll"
     2177case 66:
     2178YY_RULE_SETUP
     2179#line 235 "lex.ll"
    21732180{ KEYWORD_RETURN(LABEL); }                              // GCC
    21742181        YY_BREAK
    2175 case 66:
    2176 YY_RULE_SETUP
    2177 #line 235 "lex.ll"
     2182case 67:
     2183YY_RULE_SETUP
     2184#line 236 "lex.ll"
    21782185{ KEYWORD_RETURN(LONG); }
    21792186        YY_BREAK
    2180 case 67:
    2181 YY_RULE_SETUP
    2182 #line 236 "lex.ll"
     2187case 68:
     2188YY_RULE_SETUP
     2189#line 237 "lex.ll"
    21832190{ KEYWORD_RETURN(LVALUE); }                             // CFA
    21842191        YY_BREAK
    2185 case 68:
    2186 YY_RULE_SETUP
    2187 #line 237 "lex.ll"
     2192case 69:
     2193YY_RULE_SETUP
     2194#line 238 "lex.ll"
    21882195{ KEYWORD_RETURN(NORETURN); }                   // C11
    21892196        YY_BREAK
    2190 case 69:
    2191 YY_RULE_SETUP
    2192 #line 238 "lex.ll"
     2197case 70:
     2198YY_RULE_SETUP
     2199#line 239 "lex.ll"
    21932200{ KEYWORD_RETURN(OFFSETOF); }           // GCC
    21942201        YY_BREAK
    2195 case 70:
    2196 YY_RULE_SETUP
    2197 #line 239 "lex.ll"
     2202case 71:
     2203YY_RULE_SETUP
     2204#line 240 "lex.ll"
    21982205{ KEYWORD_RETURN(OTYPE); }                              // CFA
    21992206        YY_BREAK
    2200 case 71:
    2201 YY_RULE_SETUP
    2202 #line 240 "lex.ll"
     2207case 72:
     2208YY_RULE_SETUP
     2209#line 241 "lex.ll"
    22032210{ KEYWORD_RETURN(REGISTER); }
    22042211        YY_BREAK
    2205 case 72:
    2206 YY_RULE_SETUP
    2207 #line 241 "lex.ll"
     2212case 73:
     2213YY_RULE_SETUP
     2214#line 242 "lex.ll"
    22082215{ KEYWORD_RETURN(RESTRICT); }                   // C99
    2209         YY_BREAK
    2210 case 73:
    2211 YY_RULE_SETUP
    2212 #line 242 "lex.ll"
    2213 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    22142216        YY_BREAK
    22152217case 74:
     
    22212223YY_RULE_SETUP
    22222224#line 244 "lex.ll"
     2225{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2226        YY_BREAK
     2227case 76:
     2228YY_RULE_SETUP
     2229#line 245 "lex.ll"
    22232230{ KEYWORD_RETURN(RETURN); }
    22242231        YY_BREAK
    2225 case 76:
    2226 YY_RULE_SETUP
    2227 #line 245 "lex.ll"
     2232case 77:
     2233YY_RULE_SETUP
     2234#line 246 "lex.ll"
    22282235{ KEYWORD_RETURN(SHORT); }
    22292236        YY_BREAK
    2230 case 77:
    2231 YY_RULE_SETUP
    2232 #line 246 "lex.ll"
     2237case 78:
     2238YY_RULE_SETUP
     2239#line 247 "lex.ll"
    22332240{ KEYWORD_RETURN(SIGNED); }
    2234         YY_BREAK
    2235 case 78:
    2236 YY_RULE_SETUP
    2237 #line 247 "lex.ll"
    2238 { KEYWORD_RETURN(SIGNED); }                             // GCC
    22392241        YY_BREAK
    22402242case 79:
     
    22462248YY_RULE_SETUP
    22472249#line 249 "lex.ll"
     2250{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2251        YY_BREAK
     2252case 81:
     2253YY_RULE_SETUP
     2254#line 250 "lex.ll"
    22482255{ KEYWORD_RETURN(SIZEOF); }
    22492256        YY_BREAK
    2250 case 81:
    2251 YY_RULE_SETUP
    2252 #line 250 "lex.ll"
     2257case 82:
     2258YY_RULE_SETUP
     2259#line 251 "lex.ll"
    22532260{ KEYWORD_RETURN(STATIC); }
    22542261        YY_BREAK
    2255 case 82:
    2256 YY_RULE_SETUP
    2257 #line 251 "lex.ll"
     2262case 83:
     2263YY_RULE_SETUP
     2264#line 252 "lex.ll"
    22582265{ KEYWORD_RETURN(STATICASSERT); }               // C11
    22592266        YY_BREAK
    2260 case 83:
    2261 YY_RULE_SETUP
    2262 #line 252 "lex.ll"
     2267case 84:
     2268YY_RULE_SETUP
     2269#line 253 "lex.ll"
    22632270{ KEYWORD_RETURN(STRUCT); }
    22642271        YY_BREAK
    2265 case 84:
    2266 YY_RULE_SETUP
    2267 #line 253 "lex.ll"
     2272case 85:
     2273YY_RULE_SETUP
     2274#line 254 "lex.ll"
    22682275{ KEYWORD_RETURN(SWITCH); }
    22692276        YY_BREAK
    2270 case 85:
    2271 YY_RULE_SETUP
    2272 #line 254 "lex.ll"
     2277case 86:
     2278YY_RULE_SETUP
     2279#line 255 "lex.ll"
    22732280{ KEYWORD_RETURN(THREADLOCAL); }                // C11
    22742281        YY_BREAK
    2275 case 86:
    2276 YY_RULE_SETUP
    2277 #line 255 "lex.ll"
     2282case 87:
     2283YY_RULE_SETUP
     2284#line 256 "lex.ll"
    22782285{ KEYWORD_RETURN(THROW); }                              // CFA
    22792286        YY_BREAK
    2280 case 87:
    2281 YY_RULE_SETUP
    2282 #line 256 "lex.ll"
     2287case 88:
     2288YY_RULE_SETUP
     2289#line 257 "lex.ll"
    22832290{ KEYWORD_RETURN(THROWRESUME); }                // CFA
    22842291        YY_BREAK
    2285 case 88:
    2286 YY_RULE_SETUP
    2287 #line 257 "lex.ll"
     2292case 89:
     2293YY_RULE_SETUP
     2294#line 258 "lex.ll"
    22882295{ KEYWORD_RETURN(TRAIT); }                              // CFA
    22892296        YY_BREAK
    2290 case 89:
    2291 YY_RULE_SETUP
    2292 #line 258 "lex.ll"
     2297case 90:
     2298YY_RULE_SETUP
     2299#line 259 "lex.ll"
    22932300{ KEYWORD_RETURN(TRY); }                                // CFA
    22942301        YY_BREAK
    2295 case 90:
    2296 YY_RULE_SETUP
    2297 #line 259 "lex.ll"
     2302case 91:
     2303YY_RULE_SETUP
     2304#line 260 "lex.ll"
    22982305{ KEYWORD_RETURN(TYPEDEF); }
    2299         YY_BREAK
    2300 case 91:
    2301 YY_RULE_SETUP
    2302 #line 260 "lex.ll"
    2303 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    23042306        YY_BREAK
    23052307case 92:
     
    23162318YY_RULE_SETUP
    23172319#line 263 "lex.ll"
     2320{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2321        YY_BREAK
     2322case 95:
     2323YY_RULE_SETUP
     2324#line 264 "lex.ll"
    23182325{ KEYWORD_RETURN(UNION); }
    23192326        YY_BREAK
    2320 case 95:
    2321 YY_RULE_SETUP
    2322 #line 264 "lex.ll"
     2327case 96:
     2328YY_RULE_SETUP
     2329#line 265 "lex.ll"
    23232330{ KEYWORD_RETURN(UNSIGNED); }
    23242331        YY_BREAK
    2325 case 96:
    2326 YY_RULE_SETUP
    2327 #line 265 "lex.ll"
     2332case 97:
     2333YY_RULE_SETUP
     2334#line 266 "lex.ll"
    23282335{ KEYWORD_RETURN(VALIST); }                     // GCC
    23292336        YY_BREAK
    2330 case 97:
    2331 YY_RULE_SETUP
    2332 #line 266 "lex.ll"
     2337case 98:
     2338YY_RULE_SETUP
     2339#line 267 "lex.ll"
    23332340{ KEYWORD_RETURN(VOID); }
    23342341        YY_BREAK
    2335 case 98:
    2336 YY_RULE_SETUP
    2337 #line 267 "lex.ll"
     2342case 99:
     2343YY_RULE_SETUP
     2344#line 268 "lex.ll"
    23382345{ KEYWORD_RETURN(VOLATILE); }
    2339         YY_BREAK
    2340 case 99:
    2341 YY_RULE_SETUP
    2342 #line 268 "lex.ll"
    2343 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    23442346        YY_BREAK
    23452347case 100:
     
    23512353YY_RULE_SETUP
    23522354#line 270 "lex.ll"
     2355{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2356        YY_BREAK
     2357case 102:
     2358YY_RULE_SETUP
     2359#line 271 "lex.ll"
    23532360{ KEYWORD_RETURN(WHILE); }
    23542361        YY_BREAK
    23552362/* identifier */
    2356 case 102:
    2357 YY_RULE_SETUP
    2358 #line 273 "lex.ll"
     2363case 103:
     2364YY_RULE_SETUP
     2365#line 274 "lex.ll"
    23592366{ IDENTIFIER_RETURN(); }
    23602367        YY_BREAK
    2361 case 103:
    2362 YY_RULE_SETUP
    2363 #line 274 "lex.ll"
     2368case 104:
     2369YY_RULE_SETUP
     2370#line 275 "lex.ll"
    23642371{ ATTRIBUTE_RETURN(); }
    23652372        YY_BREAK
    2366 case 104:
    2367 YY_RULE_SETUP
    2368 #line 275 "lex.ll"
     2373case 105:
     2374YY_RULE_SETUP
     2375#line 276 "lex.ll"
    23692376{ BEGIN BKQUOTE; }
    23702377        YY_BREAK
    2371 case 105:
    2372 YY_RULE_SETUP
    2373 #line 276 "lex.ll"
     2378case 106:
     2379YY_RULE_SETUP
     2380#line 277 "lex.ll"
    23742381{ IDENTIFIER_RETURN(); }
    23752382        YY_BREAK
    2376 case 106:
    2377 YY_RULE_SETUP
    2378 #line 277 "lex.ll"
     2383case 107:
     2384YY_RULE_SETUP
     2385#line 278 "lex.ll"
    23792386{ BEGIN 0; }
    23802387        YY_BREAK
    23812388/* numeric constants */
    2382 case 107:
    2383 YY_RULE_SETUP
    2384 #line 280 "lex.ll"
     2389case 108:
     2390YY_RULE_SETUP
     2391#line 281 "lex.ll"
    23852392{ NUMERIC_RETURN(ZERO); }                               // CFA
    23862393        YY_BREAK
    2387 case 108:
    2388 YY_RULE_SETUP
    2389 #line 281 "lex.ll"
     2394case 109:
     2395YY_RULE_SETUP
     2396#line 282 "lex.ll"
    23902397{ NUMERIC_RETURN(ONE); }                                // CFA
    2391         YY_BREAK
    2392 case 109:
    2393 YY_RULE_SETUP
    2394 #line 282 "lex.ll"
    2395 { NUMERIC_RETURN(INTEGERconstant); }
    23962398        YY_BREAK
    23972399case 110:
     
    24082410YY_RULE_SETUP
    24092411#line 285 "lex.ll"
    2410 { NUMERIC_RETURN(FLOATINGconstant); }
     2412{ NUMERIC_RETURN(INTEGERconstant); }
    24112413        YY_BREAK
    24122414case 113:
     
    24152417{ NUMERIC_RETURN(FLOATINGconstant); }
    24162418        YY_BREAK
     2419case 114:
     2420YY_RULE_SETUP
     2421#line 287 "lex.ll"
     2422{ NUMERIC_RETURN(FLOATINGconstant); }
     2423        YY_BREAK
    24172424/* character constant, allows empty value */
    2418 case 114:
    2419 YY_RULE_SETUP
    2420 #line 289 "lex.ll"
     2425case 115:
     2426YY_RULE_SETUP
     2427#line 290 "lex.ll"
    24212428{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    24222429        YY_BREAK
    2423 case 115:
    2424 YY_RULE_SETUP
    2425 #line 290 "lex.ll"
     2430case 116:
     2431YY_RULE_SETUP
     2432#line 291 "lex.ll"
    24262433{ *strtext += std::string( yytext ); }
    24272434        YY_BREAK
    2428 case 116:
    2429 /* rule 116 can match eol */
    2430 YY_RULE_SETUP
    2431 #line 291 "lex.ll"
     2435case 117:
     2436/* rule 117 can match eol */
     2437YY_RULE_SETUP
     2438#line 292 "lex.ll"
    24322439{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
    24332440        YY_BREAK
    24342441/* ' stop highlighting */
    24352442/* string constant */
    2436 case 117:
    2437 YY_RULE_SETUP
    2438 #line 295 "lex.ll"
     2443case 118:
     2444YY_RULE_SETUP
     2445#line 296 "lex.ll"
    24392446{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    24402447        YY_BREAK
    2441 case 118:
    2442 YY_RULE_SETUP
    2443 #line 296 "lex.ll"
     2448case 119:
     2449YY_RULE_SETUP
     2450#line 297 "lex.ll"
    24442451{ *strtext += std::string( yytext ); }
    24452452        YY_BREAK
    2446 case 119:
    2447 /* rule 119 can match eol */
    2448 YY_RULE_SETUP
    2449 #line 297 "lex.ll"
     2453case 120:
     2454/* rule 120 can match eol */
     2455YY_RULE_SETUP
     2456#line 298 "lex.ll"
    24502457{ BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
    24512458        YY_BREAK
    24522459/* " stop highlighting */
    24532460/* common character/string constant */
    2454 case 120:
    2455 YY_RULE_SETUP
    2456 #line 301 "lex.ll"
     2461case 121:
     2462YY_RULE_SETUP
     2463#line 302 "lex.ll"
    24572464{ rm_underscore(); *strtext += std::string( yytext ); }
    24582465        YY_BREAK
    2459 case 121:
    2460 /* rule 121 can match eol */
    2461 YY_RULE_SETUP
    2462 #line 302 "lex.ll"
     2466case 122:
     2467/* rule 122 can match eol */
     2468YY_RULE_SETUP
     2469#line 303 "lex.ll"
    24632470{}                                              // continuation (ALSO HANDLED BY CPP)
    24642471        YY_BREAK
    2465 case 122:
    2466 YY_RULE_SETUP
    2467 #line 303 "lex.ll"
     2472case 123:
     2473YY_RULE_SETUP
     2474#line 304 "lex.ll"
    24682475{ *strtext += std::string( yytext ); } // unknown escape character
    24692476        YY_BREAK
    24702477/* punctuation */
    2471 case 123:
    2472 YY_RULE_SETUP
    2473 #line 306 "lex.ll"
    2474 { ASCIIOP_RETURN(); }
    2475         YY_BREAK
    24762478case 124:
    24772479YY_RULE_SETUP
     
    25022504YY_RULE_SETUP
    25032505#line 312 "lex.ll"
     2506{ ASCIIOP_RETURN(); }
     2507        YY_BREAK
     2508case 130:
     2509YY_RULE_SETUP
     2510#line 313 "lex.ll"
    25042511{ ASCIIOP_RETURN(); }                                   // also operator
    2505         YY_BREAK
    2506 case 130:
    2507 YY_RULE_SETUP
    2508 #line 313 "lex.ll"
    2509 { ASCIIOP_RETURN(); }
    25102512        YY_BREAK
    25112513case 131:
     
    25172519YY_RULE_SETUP
    25182520#line 315 "lex.ll"
     2521{ ASCIIOP_RETURN(); }
     2522        YY_BREAK
     2523case 133:
     2524YY_RULE_SETUP
     2525#line 316 "lex.ll"
    25192526{ ASCIIOP_RETURN(); }                                   // also operator
    25202527        YY_BREAK
    2521 case 133:
    2522 YY_RULE_SETUP
    2523 #line 316 "lex.ll"
     2528case 134:
     2529YY_RULE_SETUP
     2530#line 317 "lex.ll"
    25242531{ NAMEDOP_RETURN(ELLIPSIS); }
    25252532        YY_BREAK
    25262533/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
    2527 case 134:
    2528 YY_RULE_SETUP
    2529 #line 319 "lex.ll"
     2534case 135:
     2535YY_RULE_SETUP
     2536#line 320 "lex.ll"
    25302537{ RETURN_VAL('['); }
    25312538        YY_BREAK
    2532 case 135:
    2533 YY_RULE_SETUP
    2534 #line 320 "lex.ll"
     2539case 136:
     2540YY_RULE_SETUP
     2541#line 321 "lex.ll"
    25352542{ RETURN_VAL(']'); }
    25362543        YY_BREAK
    2537 case 136:
    2538 YY_RULE_SETUP
    2539 #line 321 "lex.ll"
     2544case 137:
     2545YY_RULE_SETUP
     2546#line 322 "lex.ll"
    25402547{ RETURN_VAL('{'); }
    25412548        YY_BREAK
    2542 case 137:
    2543 YY_RULE_SETUP
    2544 #line 322 "lex.ll"
     2549case 138:
     2550YY_RULE_SETUP
     2551#line 323 "lex.ll"
    25452552{ RETURN_VAL('}'); }
    25462553        YY_BREAK
    25472554/* operators */
    2548 case 138:
    2549 YY_RULE_SETUP
    2550 #line 325 "lex.ll"
    2551 { ASCIIOP_RETURN(); }
    2552         YY_BREAK
    25532555case 139:
    25542556YY_RULE_SETUP
     
    26182620case 152:
    26192621YY_RULE_SETUP
    2620 #line 340 "lex.ll"
     2622#line 339 "lex.ll"
     2623{ ASCIIOP_RETURN(); }
     2624        YY_BREAK
     2625case 153:
     2626YY_RULE_SETUP
     2627#line 341 "lex.ll"
    26212628{ NAMEDOP_RETURN(ICR); }
    26222629        YY_BREAK
    2623 case 153:
    2624 YY_RULE_SETUP
    2625 #line 341 "lex.ll"
     2630case 154:
     2631YY_RULE_SETUP
     2632#line 342 "lex.ll"
    26262633{ NAMEDOP_RETURN(DECR); }
    26272634        YY_BREAK
    2628 case 154:
    2629 YY_RULE_SETUP
    2630 #line 342 "lex.ll"
     2635case 155:
     2636YY_RULE_SETUP
     2637#line 343 "lex.ll"
    26312638{ NAMEDOP_RETURN(EQ); }
    26322639        YY_BREAK
    2633 case 155:
    2634 YY_RULE_SETUP
    2635 #line 343 "lex.ll"
     2640case 156:
     2641YY_RULE_SETUP
     2642#line 344 "lex.ll"
    26362643{ NAMEDOP_RETURN(NE); }
    26372644        YY_BREAK
    2638 case 156:
    2639 YY_RULE_SETUP
    2640 #line 344 "lex.ll"
     2645case 157:
     2646YY_RULE_SETUP
     2647#line 345 "lex.ll"
    26412648{ NAMEDOP_RETURN(LS); }
    26422649        YY_BREAK
    2643 case 157:
    2644 YY_RULE_SETUP
    2645 #line 345 "lex.ll"
     2650case 158:
     2651YY_RULE_SETUP
     2652#line 346 "lex.ll"
    26462653{ NAMEDOP_RETURN(RS); }
    26472654        YY_BREAK
    2648 case 158:
    2649 YY_RULE_SETUP
    2650 #line 346 "lex.ll"
     2655case 159:
     2656YY_RULE_SETUP
     2657#line 347 "lex.ll"
    26512658{ NAMEDOP_RETURN(LE); }
    26522659        YY_BREAK
    2653 case 159:
    2654 YY_RULE_SETUP
    2655 #line 347 "lex.ll"
     2660case 160:
     2661YY_RULE_SETUP
     2662#line 348 "lex.ll"
    26562663{ NAMEDOP_RETURN(GE); }
    26572664        YY_BREAK
    2658 case 160:
    2659 YY_RULE_SETUP
    2660 #line 348 "lex.ll"
     2665case 161:
     2666YY_RULE_SETUP
     2667#line 349 "lex.ll"
    26612668{ NAMEDOP_RETURN(ANDAND); }
    26622669        YY_BREAK
    2663 case 161:
    2664 YY_RULE_SETUP
    2665 #line 349 "lex.ll"
     2670case 162:
     2671YY_RULE_SETUP
     2672#line 350 "lex.ll"
    26662673{ NAMEDOP_RETURN(OROR); }
    26672674        YY_BREAK
    2668 case 162:
    2669 YY_RULE_SETUP
    2670 #line 350 "lex.ll"
     2675case 163:
     2676YY_RULE_SETUP
     2677#line 351 "lex.ll"
    26712678{ NAMEDOP_RETURN(ARROW); }
    26722679        YY_BREAK
    2673 case 163:
    2674 YY_RULE_SETUP
    2675 #line 351 "lex.ll"
     2680case 164:
     2681YY_RULE_SETUP
     2682#line 352 "lex.ll"
    26762683{ NAMEDOP_RETURN(PLUSassign); }
    26772684        YY_BREAK
    2678 case 164:
    2679 YY_RULE_SETUP
    2680 #line 352 "lex.ll"
     2685case 165:
     2686YY_RULE_SETUP
     2687#line 353 "lex.ll"
    26812688{ NAMEDOP_RETURN(MINUSassign); }
    26822689        YY_BREAK
    2683 case 165:
    2684 YY_RULE_SETUP
    2685 #line 353 "lex.ll"
     2690case 166:
     2691YY_RULE_SETUP
     2692#line 354 "lex.ll"
    26862693{ NAMEDOP_RETURN(MULTassign); }
    26872694        YY_BREAK
    2688 case 166:
    2689 YY_RULE_SETUP
    2690 #line 354 "lex.ll"
     2695case 167:
     2696YY_RULE_SETUP
     2697#line 355 "lex.ll"
    26912698{ NAMEDOP_RETURN(DIVassign); }
    26922699        YY_BREAK
    2693 case 167:
    2694 YY_RULE_SETUP
    2695 #line 355 "lex.ll"
     2700case 168:
     2701YY_RULE_SETUP
     2702#line 356 "lex.ll"
    26962703{ NAMEDOP_RETURN(MODassign); }
    26972704        YY_BREAK
    2698 case 168:
    2699 YY_RULE_SETUP
    2700 #line 356 "lex.ll"
     2705case 169:
     2706YY_RULE_SETUP
     2707#line 357 "lex.ll"
    27012708{ NAMEDOP_RETURN(ANDassign); }
    27022709        YY_BREAK
    2703 case 169:
    2704 YY_RULE_SETUP
    2705 #line 357 "lex.ll"
     2710case 170:
     2711YY_RULE_SETUP
     2712#line 358 "lex.ll"
    27062713{ NAMEDOP_RETURN(ORassign); }
    27072714        YY_BREAK
    2708 case 170:
    2709 YY_RULE_SETUP
    2710 #line 358 "lex.ll"
     2715case 171:
     2716YY_RULE_SETUP
     2717#line 359 "lex.ll"
    27112718{ NAMEDOP_RETURN(ERassign); }
    27122719        YY_BREAK
    2713 case 171:
    2714 YY_RULE_SETUP
    2715 #line 359 "lex.ll"
     2720case 172:
     2721YY_RULE_SETUP
     2722#line 360 "lex.ll"
    27162723{ NAMEDOP_RETURN(LSassign); }
    27172724        YY_BREAK
    2718 case 172:
    2719 YY_RULE_SETUP
    2720 #line 360 "lex.ll"
     2725case 173:
     2726YY_RULE_SETUP
     2727#line 361 "lex.ll"
    27212728{ NAMEDOP_RETURN(RSassign); }
    27222729        YY_BREAK
    2723 case 173:
    2724 YY_RULE_SETUP
    2725 #line 362 "lex.ll"
    2726 { NAMEDOP_RETURN(ATassign); }
     2730case 174:
     2731YY_RULE_SETUP
     2732#line 363 "lex.ll"
     2733{ NAMEDOP_RETURN(ATassign); }                   // CFA
    27272734        YY_BREAK
    27282735/* CFA, operator identifier */
    2729 case 174:
    2730 YY_RULE_SETUP
    2731 #line 365 "lex.ll"
     2736case 175:
     2737YY_RULE_SETUP
     2738#line 366 "lex.ll"
    27322739{ IDENTIFIER_RETURN(); }                                // unary
    2733         YY_BREAK
    2734 case 175:
    2735 YY_RULE_SETUP
    2736 #line 366 "lex.ll"
    2737 { IDENTIFIER_RETURN(); }
    27382740        YY_BREAK
    27392741case 176:
     
    27452747YY_RULE_SETUP
    27462748#line 368 "lex.ll"
     2749{ IDENTIFIER_RETURN(); }
     2750        YY_BREAK
     2751case 178:
     2752YY_RULE_SETUP
     2753#line 369 "lex.ll"
    27472754{ IDENTIFIER_RETURN(); }                // binary
    27482755        YY_BREAK
     
    27732780          an argument list.
    27742781        */
    2775 case 178:
    2776 YY_RULE_SETUP
    2777 #line 395 "lex.ll"
     2782case 179:
     2783YY_RULE_SETUP
     2784#line 396 "lex.ll"
    27782785{
    27792786        // 1 or 2 character unary operator ?
     
    27882795        YY_BREAK
    27892796/* unknown characters */
    2790 case 179:
    2791 YY_RULE_SETUP
    2792 #line 407 "lex.ll"
     2797case 180:
     2798YY_RULE_SETUP
     2799#line 408 "lex.ll"
    27932800{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    27942801        YY_BREAK
    2795 case 180:
    2796 YY_RULE_SETUP
    2797 #line 409 "lex.ll"
     2802case 181:
     2803YY_RULE_SETUP
     2804#line 410 "lex.ll"
    27982805ECHO;
    27992806        YY_BREAK
    2800 #line 2801 "Parser/lex.cc"
     2807#line 2808 "Parser/lex.cc"
    28012808case YY_STATE_EOF(INITIAL):
    28022809case YY_STATE_EOF(COMMENT):
     
    30953102                        {
    30963103                        yy_current_state = (int) yy_def[yy_current_state];
    3097                         if ( yy_current_state >= 888 )
     3104                        if ( yy_current_state >= 892 )
    30983105                                yy_c = yy_meta[(unsigned int) yy_c];
    30993106                        }
     
    31233130                {
    31243131                yy_current_state = (int) yy_def[yy_current_state];
    3125                 if ( yy_current_state >= 888 )
     3132                if ( yy_current_state >= 892 )
    31263133                        yy_c = yy_meta[(unsigned int) yy_c];
    31273134                }
    31283135        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    3129         yy_is_jam = (yy_current_state == 887);
     3136        yy_is_jam = (yy_current_state == 891);
    31303137
    31313138        return yy_is_jam ? 0 : yy_current_state;
     
    37733780#define YYTABLES_NAME "yytables"
    37743781
    3775 #line 409 "lex.ll"
     3782#line 410 "lex.ll"
    37763783
    37773784
  • src/Parser/lex.ll

    re4957e7 rbecba789  
    99 * Author           : Peter A. Buhr
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    11  * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Jun 23 07:29:30 2016
    13  * Update Count     : 457
     11 * Last Modified By :
     12 * Last Modified On : Sun Jul 31 07:19:36 2016
     13 * Update Count     : 459
    1414 */
    1515
     
    213213__extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
    214214extern                  { KEYWORD_RETURN(EXTERN); }
     215fallthrough             { KEYWORD_RETURN(FALLTHRU); }                   // CFA
    215216fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA
    216217finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
     
    360361">>="                   { NAMEDOP_RETURN(RSassign); }
    361362
    362 "@="                    { NAMEDOP_RETURN(ATassign); }
     363"@="                    { NAMEDOP_RETURN(ATassign); }                   // CFA
    363364
    364365                                /* CFA, operator identifier */
  • src/tests/switch.c

    re4957e7 rbecba789  
    1010// Created On       : Tue Jul 12 06:50:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 18:02:23 2016
    13 // Update Count     : 22
     12// Last Modified On : Sat Jul 30 14:41:32 2016
     13// Update Count     : 30
    1414//
    1515
     
    3333        } // switch
    3434
    35         // switch (3 ) {
    36         //      int j;
    37         //   case 3:
    38         //      break;
    39         //   case 4:
    40         //      j = 0;
    41         // }
     35        switch ( 3 ) {
     36                int j;
     37          case 3:
     38                break;
     39          case 4:
     40                j = 0;
     41        }
    4242
    4343        switch ( i ) {
     
    4949          default:
    5050                i = 3;
    51           case 3:
     51          case 19:
    5252          case 'A' ... 'Z':
    53           case 5 ... 6:
    54           case 2, 4:
     53          case 1 ... 6:
     54          case 20, 30:
    5555                j = 3;
    5656                f( 3 );
     
    7878                struct S { int i; };
    7979                S s;
    80           case 3:
     80          case 19:
    8181          case 'A' ... 'Z':
    82           case 5 ... 6:
    83           case 2, 4, 7:
     82          case 0 ... 6:
     83          case 20, 30, 40:
    8484                i = 3;
    8585                f( 3 );
  • src/tests/test.py

    re4957e7 rbecba789  
    3333def listTests():
    3434        machineType = getMachineType()
    35 
    36         print(machineType)
    3735
    3836        # tests directly in the .expect folder will always be processed
Note: See TracChangeset for help on using the changeset viewer.