Changeset 37218fc

doc/refrat/Makefile

-                      r3aba311
+                      r37218fc
 ## Define the appropriate configuration variables.
+Macros =
+TeXLIB = .:${Macros}:
+TeXLIB = .:../bibliography/:../LaTeXmacros/:
 LaTeX  = TEXINPUTS=${TeXLIB} && export TEXINPUTS && latex
 BibTeX = BSTINPUTS=${TeXLIB} && export BSTINPUTS && bibtex
+BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex
 ## Define the text source files.
 …
         dvips $< -o $@
+${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex ${basename ${DOCUMENT}}.bib
+${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \
+                ../LaTeXmacros/common.tex ../LaTeXmacros/indexstyle ../bibliography/cfa.bib
         # Conditionally create an empty *.ind (index) file for inclusion until makeindex is run.
         if [ ! -r ${basename $@}.ind ] ; then touch ${basename $@}.ind ; fi
 …
         -${BibTeX} ${basename $@}
         # Make index from *.aux entries and input index at end of document
         makeindex -s indexstyle ${basename $@}.idx
+        makeindex -s ../LaTeXmacros/indexstyle ${basename $@}.idx
         ${LaTeX} ${basename $@}.tex
         # Run again to get index title into table of contents

doc/refrat/refrat.tex

-                      r3aba311
+                      r37218fc
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+%%
+%% The contents of this file are covered under the licence agreement in the
+%% file "LICENCE" distributed with Cforall.
+%%
+%% refrat.tex --
+%%
+%% Author           : Peter A. Buhr
+%% Created On       : Wed Apr  6 14:52:25 2016
+%% Last Modified By : Peter A. Buhr
+%% Last Modified On : Fri Apr  8 18:32:07 2016
+%% Update Count     : 6
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 …
 % Latex packages used in the document.
 \usepackage{fullpage,times}
 \usepackage{xspace}
 …
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Names used in the document.
-\newcommand{\CFA}{C$\forall$\xspace}    % set language symbolic name
-\newcommand{\CFL}{Cforall\xspace}               % set language text name
-\newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
-\def\c11{ISO/IEC C} % C11 name (cannot have numbers in latex command name)
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Bespoke macros used in the document.
+\makeatletter
+% allow escape sequence in lstinline
+%\usepackage{etoolbox}
+%\patchcmd{\lsthk@TextStyle}{\let\lst@DefEsc\@empty}{}{}{\errmessage{failed to patch}}
+\renewcommand\small{%
+   \@setfontsize\small{8.5}{11}%
+   \abovedisplayskip 8.5pt \@plus 3pt \@minus 4pt
+   \abovedisplayshortskip \z@ \@plus 2pt
+   \belowdisplayshortskip 4pt \@plus 2pt \@minus 2pt
+   \def\@listi{\leftmargin\leftmargini
+               \topsep 4pt \@plus 2pt \@minus 2pt
+               \parsep 2pt \@pluspt \@minuspt
+               \itemsep \parsep}%
+   \belowdisplayskip \abovedisplayskip
+}
+\usepackage{relsize}            % must be after change to small
+\renewcommand{\labelitemi}{{\raisebox{0.25ex}{\footnotesize$\bullet$}}}
+\renewenvironment{itemize}{\begin{list}{\labelitemi}{\topsep=5pt\itemsep=5pt\parsep=0pt}}{\end{list}}
+%  Reduce size of chapter/section titles
+\def\@makechapterhead#1{%
+  \vspace*{50\p@}%
+  {\parindent \z@ \raggedright \normalfont
+    \ifnum \c@secnumdepth >\m@ne
+        \large\bfseries \@chapapp\space \thechapter
+        \par\nobreak
+        \vskip 5\p@
+    \fi
+    \interlinepenalty\@M
+    \Large \bfseries #1\par\nobreak
+    \vskip 50\p@
+  }}
+\def\@makeschapterhead#1{%
+  \vspace*{50\p@}%
+  {\parindent \z@ \raggedright
+    \normalfont
+    \interlinepenalty\@M
+    \Large \bfseries  #1\par\nobreak
+    \vskip 50\p@
+  }}
+\renewcommand\section{\@startsection{section}{1}{\z@}{-3.0ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\large\bfseries}}
+\renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
+\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
+\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries}}
+% index macros
+\newcommand{\italic}[1]{\emph{\hyperpage{#1}}}
+\newcommand{\definition}[1]{\textbf{\hyperpage{#1}}}
+\newcommand{\see}[1]{\emph{see} #1}
+% Define some commands that produce formatted index entries suitable for cross-references.
+% ``\spec'' produces entries for specifications of entities.  ``\impl'' produces entries for their
+% implementations, and ``\use'' for their uses.
+%  \newcommand{\bold}[1]{{\bf #1}}
+%  \def\spec{\@bsphack\begingroup
+%             \def\protect##1{\string##1\space}\@sanitize
+%             \@wrxref{|bold}}
+\def\impl{\@bsphack\begingroup
+          \def\protect##1{\string##1\space}\@sanitize
+          \@wrxref{|definition}}
+\newcommand{\indexcode}[1]{{\lstinline$#1$}}
+\def\use{\@bsphack\begingroup
+         \def\protect##1{\string##1\space}\@sanitize
+         \@wrxref{|hyperpage}}
+\def\@wrxref#1#2{\let\thepage\relax
+    \xdef\@gtempa{\write\@indexfile{\string
+    \indexentry{#2@{\lstinline$#2$}#1}{\thepage}}}\endgroup\@gtempa
+    \if@nobreak \ifvmode\nobreak\fi\fi\@esphack}
+%\newcommand{\use}[1]{\index{#1@{\lstinline$#1$}}}
+%\newcommand{\impl}[1]{\index{\protect#1@{\lstinline$\protect#1$}|definition}}
+% inline text and lowercase index: \Index{inline and lowercase index text}
+% inline text and as-in index: \Index[as-is index text]{inline text}
+% inline text but index with different as-is text: \Index[index text]{inline text}
+\newcommand{\Index}{\@ifstar\@sIndex\@Index}
+\newcommand{\@Index}[2][\@empty]{\lowercase{\def\temp{#2}}#2\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
+\newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
+\makeatother
+% blocks and titles
+\newenvironment{rationale}{%
+  \begin{quotation}\noindent$\Box$\enspace
+}{%
+  \hfill\enspace$\Box$\end{quotation}
+}%
+\newcommand{\define}[1]{\emph{#1\/}\index{#1}}
+\newcommand{\rewrite}{\(\Rightarrow\)}
+\newcommand{\rewriterules}{\paragraph{Rewrite Rules}~\par\noindent}
+\newcommand{\examples}{\paragraph{Examples}~\par\noindent}
+\newcommand{\semantics}{\paragraph{Semantics}~\par\noindent}
+\newcommand{\constraints}{\paragraph{Constraints}~\par\noindent}
+\newcommand{\predefined}{\paragraph{Predefined Identifiers}~\par\noindent}
+% BNF macros
+\def\syntax{\paragraph{Syntax}\trivlist\parindent=.5in\item[\hskip.5in]}
+\let\endsyntax=\endtrivlist
+\newcommand{\lhs}[1]{\par{\emph{#1:}}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\rhs}{\hfil\break\hbox{\hskip1in}}
+\newcommand{\oldlhs}[1]{\emph{#1: \ldots}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\nonterm}[1]{\emph{#1\/}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\opt}{$_{opt}$\ }
+% adjust varioref package with default "section" and "page" titles, and optional title with faraway page numbers
+% \VRef{label} => Section 2.7, \VPageref{label} => page 17
+% \VRef[Figure]{label} => Figure 3.4, \VPageref{label} => page 17
+\renewcommand{\reftextfaceafter}{\unskip}
+\renewcommand{\reftextfacebefore}{\unskip}
+\renewcommand{\reftextafter}{\unskip}
+\renewcommand{\reftextbefore}{\unskip}
+\renewcommand{\reftextfaraway}[1]{\unskip, p.~\pageref{#1}}
+\renewcommand{\reftextpagerange}[2]{\unskip, pp.~\pageref{#1}--\pageref{#2}}
+\newcommand{\VRef}[2][Section]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vref{#2}}
+\newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}}
+% CFA based on ANSI C
+\lstdefinelanguage{CFA}[ANSI]{C}%
+{morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,trait,disable,dtype,enable,
+        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,otype,restrict,_Static_assert,
+        _Thread_local,throw,throwResume,try,},
+}%
+\lstset{
+language=CFA,
+columns=flexible,
+basicstyle=\sf\relsize{-1},
+tabsize=4,
+xleftmargin=\parindent,
+escapechar=@,
+keepspaces=true,
+showstringspaces=false,
+showlines=true,
+}%
+\makeatletter
+% replace/adjust listings characters that look bad in sanserif
+\lst@CCPutMacro
+\lst@ProcessOther{"2D}{\lst@ttfamily{-{}}{{\ttfamily\upshape -}}} % replace minus
+\lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
+\lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
+\lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex
+\lst@ProcessLetter{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
+\lst@ProcessOther{"7E}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}} % replace tilde
+%\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde
+\@empty\z@\@empty
+\makeatother
+\input{common}
 \setcounter{secnumdepth}{3}     % number subsubsections
 …
 This document is a reference manual and rationale for \CFA, a polymorphic extension of the C programming language.
 It makes frequent reference to the {\c11} standard \cite{ANS:C11}, and occasionally compares \CFA to {\CC} \cite{c++}.
+It makes frequent reference to the {\c11} standard \cite{C11}, and occasionally compares \CFA to {\CC} \cite{C++}.
 The manual deliberately imitates the ordering of the {\c11} standard (although the section numbering differs).
 …
 There are two notable differences between \CFA's overload resolution rules and the rules for
 {\CC} defined in \cite{c++}.
+{\CC} defined in \cite{C++}.
 First, the result type of a function plays a role.
 In {\CC}, a function call must be completely resolved based on the arguments to the call in most circumstances.
 …
 \begin{itemize}
 \item
 Inside a Clu cluster \cite{clu}, the declaration of an instance states which view applies.
+Inside a Clu cluster \cite{CLU}, the declaration of an instance states which view applies.
 Two primitives called \lstinline$up$ and \lstinline$down$ can be used to convert between the views.
 \item
 The Simula class \cite{Simula87} is essentially a record type.
+The Simula class \cite{SIMULA87} is essentially a record type.
 Since the only operations on a record are member selection and assignment, which can not be overloaded, there is never any ambiguity as to whether the abstraction or the implementation view is being used.
 In {\CC}
 \cite{c++}, operations on class instances include assignment and ``\lstinline$&$'', which can be overloaded.
+\cite{C++}, operations on class instances include assignment and ``\lstinline$&$'', which can be overloaded.
 A ``scope resolution'' operator can be used inside the class to specify whether the abstract or implementation version of the operation should be used.
 \item
 An Ada derived type definition \cite{ada} creates a new type from an old type, and also implicitly declares derived subprograms that correspond to the existing subprograms that use the old type as a parameter type or result type.
+An Ada derived type definition \cite{Ada} creates a new type from an old type, and also implicitly declares derived subprograms that correspond to the existing subprograms that use the old type as a parameter type or result type.
 The derived subprograms are clones of the existing subprograms with the old type replaced by the derived type.
 Literals and aggregates of the old type are also cloned.
 …
 ``\lstinline$Safe_pointer$ acts like a pointer to \lstinline$int$''.
 \begin{lstlisting}
 trait ptr_to( type P | pointer( P ), otype T ) {@\impl{ptr_to}@@\use{pointer}@
+trait ptr_to( otype P | pointer( P ), otype T ) {@\impl{ptr_to}@@\use{pointer}@
         lvalue T *?( P );
         lvalue T ?[?]( P, long int );
 };
 trait ptr_to_const( type P | pointer( P ), otype T ) {@\impl{ptr_to_const}@
+trait ptr_to_const( otype P | pointer( P ), otype T ) {@\impl{ptr_to_const}@
         const lvalue T *?( P );
         const lvalue T ?[?]( P, long int );@\use{pointer}@
 };
 trait ptr_to_volatile( type P | pointer( P ), otype T ) }@\impl{ptr_to_volatile}@
+trait ptr_to_volatile( otype P | pointer( P ), otype T ) }@\impl{ptr_to_volatile}@
         volatile lvalue T *?( P );
         volatile lvalue T ?[?]( P, long int );@\use{pointer}@
 };
 trait ptr_to_const_volatile( type P | pointer( P ), otype T ) }@\impl{ptr_to_const_volatile}@
+trait ptr_to_const_volatile( otype P | pointer( P ), otype T ) }@\impl{ptr_to_const_volatile}@
         const volatile lvalue T *?( P );@\use{pointer}@
         const volatile lvalue T ?[?]( P, long int );
 …
 ``\lstinline$ptr_to$'' specifications.
 \begin{lstlisting}
 trait m_l_ptr_to( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ otype T | ptr_to( P, T )@\use{ptr_to}@ {
+trait m_l_ptr_to( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ otype T | ptr_to( P, T )@\use{ptr_to}@ {
         P ?=?( P *, T * );
         T * ?=?( T **, P );
 };
 trait m_l_ptr_to_const( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ otype T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
+trait m_l_ptr_to_const( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ otype T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
         P ?=?( P *, const T * );
         const T * ?=?( const T **, P );
 };
 trait m_l_ptr_to_volatile( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ otype T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
+trait m_l_ptr_to_volatile( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ otype T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
         P ?=?( P *, volatile T * );
         volatile T * ?=?( volatile T **, P );
 };
 trait m_l_ptr_to_const_volatile( type P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
                 type T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {@\use{m_l_ptr_to_const}@@\use{m_l_ptr_to_volatile}@
+trait m_l_ptr_to_const_volatile( otype P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
+                otype T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {@\use{m_l_ptr_to_const}@@\use{m_l_ptr_to_volatile}@
         P ?=?( P *, const volatile T * );
         const volatile T * ?=?( const volatile T **, P );
 …
 \bibliographystyle{plain}
 \bibliography{refrat}
+\bibliography{cfa}

doc/user/Makefile

-                      r3aba311
+                      r37218fc
 ## Define the appropriate configuration variables.
 TeXLIB = .::
+TeXLIB = .:../bibliography/:../LaTeXmacros/:
 LaTeX  = TEXINPUTS=${TeXLIB} && export TEXINPUTS && latex
 BibTeX = BSTINPUTS=${TeXLIB} && export BSTINPUTS && bibtex
+BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex
 ## Define the text source files.
 …
         dvips $< -o $@
+${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex ${basename ${DOCUMENT}}.bib /usr/local/bibliographies/pl.bib
+${basename ${DOCUMENT}}.dvi : Makefile ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} ${basename ${DOCUMENT}}.tex \
+                ../LaTeXmacros/common.tex ../LaTeXmacros/indexstyle ../bibliography/cfa.bib
         # Conditionally create an empty *.ind (index) file for inclusion until makeindex is run.
         if [ ! -r ${basename $@}.ind ] ; then touch ${basename $@}.ind ; fi
 …
         -${BibTeX} ${basename $@}
         # Make index from *.aux entries and input index at end of document
         makeindex -s indexstyle ${basename $@}.idx
+        makeindex -s ../LaTeXmacros/indexstyle ${basename $@}.idx
         ${LaTeX} ${basename $@}.tex
         # Run again to get index title into table of contents

doc/user/user.tex

-                      r3aba311
+                      r37218fc
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+%%
+%% The contents of this file are covered under the licence agreement in the
+%% file "LICENCE" distributed with Cforall.
+%%
+%% user.tex --
+%%
+%% Author           : Peter A. Buhr
+%% Created On       : Wed Apr  6 14:53:29 2016
+%% Last Modified By : Peter A. Buhr
+%% Last Modified On : Fri Apr  8 11:40:53 2016
+%% Update Count     : 42
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 …
 % Latex packages used in the document.
+\usepackage[T1]{fontenc}
+\usepackage{textcomp}
+\usepackage[latin1]{inputenc}
+\usepackage{upquote}
 \usepackage{fullpage,times}
 \usepackage{xspace}
 …
 % Names used in the document.
-\newcommand{\CFA}{C$\forall$\xspace}    % set language symbolic name
-\newcommand{\CFL}{Cforall\xspace}               % set language text name
-\newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
-\def\c11{ISO/IEC C} % C11 name (cannot have numbers in latex command name)
 \newcommand{\CS}{C\raisebox{-0.9ex}{\large$^\sharp$}\xspace}
 …
 % Bespoke macros used in the document.
+\makeatletter
+% allow escape sequence in lstinline
+%\usepackage{etoolbox}
+%\patchcmd{\lsthk@TextStyle}{\let\lst@DefEsc\@empty}{}{}{\errmessage{failed to patch}}
+\renewcommand\small{%
+   \@setfontsize\small{8.5}{11}%
+   \abovedisplayskip 8.5pt \@plus 3pt \@minus 4pt
+   \abovedisplayshortskip \z@ \@plus 2pt
+   \belowdisplayshortskip 4pt \@plus 2pt \@minus 2pt
+   \def\@listi{\leftmargin\leftmargini
+               \topsep 4pt \@plus 2pt \@minus 2pt
+               \parsep 2pt \@pluspt \@minuspt
+               \itemsep \parsep}%
+   \belowdisplayskip \abovedisplayskip
+}
+\usepackage{relsize}            % must be after change to small
+\renewcommand{\labelitemi}{{\raisebox{0.25ex}{\footnotesize$\bullet$}}}
+\renewenvironment{itemize}{\begin{list}{\labelitemi}{\topsep=5pt\itemsep=5pt\parsep=0pt}}{\end{list}}
+%  Reduce size of section titles
+\renewcommand\section{\@startsection{section}{1}{\z@}{-3.0ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\large\bfseries}}
+\renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
+\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
+\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries}}
+% index macros
+\newcommand{\italic}[1]{\emph{\hyperpage{#1}}}
+\newcommand{\definition}[1]{\textbf{\hyperpage{#1}}}
+\newcommand{\see}[1]{\emph{see} #1}
+% Define some commands that produce formatted index entries suitable for cross-references.
+% ``\spec'' produces entries for specifications of entities.  ``\impl'' produces entries for their
+% implementations, and ``\use'' for their uses.
+%  \newcommand{\bold}[1]{{\bf #1}}
+%  \def\spec{\@bsphack\begingroup
+%             \def\protect##1{\string##1\space}\@sanitize
+%             \@wrxref{|bold}}
+\def\impl{\@bsphack\begingroup
+          \def\protect##1{\string##1\space}\@sanitize
+          \@wrxref{|definition}}
+\newcommand{\indexcode}[1]{{\lstinline$#1$}}
+\def\use{\@bsphack\begingroup
+         \def\protect##1{\string##1\space}\@sanitize
+         \@wrxref{|hyperpage}}
+\def\@wrxref#1#2{\let\thepage\relax
+    \xdef\@gtempa{\write\@indexfile{\string
+    \indexentry{#2@{\lstinline$#2$}#1}{\thepage}}}\endgroup\@gtempa
+    \if@nobreak \ifvmode\nobreak\fi\fi\@esphack}
+%\newcommand{\use}[1]{\index{#1@{\lstinline$#1$}}}
+%\newcommand{\impl}[1]{\index{\protect#1@{\lstinline$\protect#1$}|definition}}
+% inline text and lowercase index: \Index{inline and lowercase index text}
+% inline text and as-in index: \Index[as-is index text]{inline text}
+% inline text but index with different as-is text: \Index[index text]{inline text}
+\newcommand{\Index}{\@ifstar\@sIndex\@Index}
+\newcommand{\@Index}[2][\@empty]{\lowercase{\def\temp{#2}}#2\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
+\newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
+\newcommand{\newtermFontInline}{\emph}
+\newcommand{\newterm}{\@ifstar\@snewterm\@newterm}
+\newcommand{\@newterm}[2][\@empty]{\lowercase{\def\temp{#2}}{\newtermFontInline{#2}}\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
+\newcommand{\@snewterm}[2][\@empty]{{\newtermFontInline{#2}}\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
+\makeatother
+% blocks and titles
+\newenvironment{quote2}{%
+        \list{}{\lstset{resetmargins=true}\leftmargin=\parindent\rightmargin\leftmargin}%
+        \item\relax
+}{%
+        \endlist
+}% quote2
+\newenvironment{rationale}{%
+  \begin{quotation}\noindent$\Box$\enspace
+}{%
+  \hfill\enspace$\Box$\end{quotation}
+}%
+\newcommand{\define}[1]{\emph{#1\/}\index{#1}}
+\newcommand{\rewrite}{\(\Rightarrow\)}
+\newcommand{\rewriterules}{\paragraph{Rewrite Rules}~\par\noindent}
+\newcommand{\examples}{\paragraph{Examples}~\par\noindent}
+\newcommand{\semantics}{\paragraph{Semantics}~\par\noindent}
+\newcommand{\constraints}{\paragraph{Constraints}~\par\noindent}
+\newcommand{\predefined}{\paragraph{Predefined Identifiers}~\par\noindent}
+% BNF macros
+\def\syntax{\paragraph{Syntax}\trivlist\parindent=.5in\item[\hskip.5in]}
+\let\endsyntax=\endtrivlist
+\newcommand{\lhs}[1]{\par{\emph{#1:}}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\rhs}{\hfil\break\hbox{\hskip1in}}
+\newcommand{\oldlhs}[1]{\emph{#1: \ldots}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\nonterm}[1]{\emph{#1\/}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\opt}{$_{opt}$\ }
+% adjust varioref package with default "section" and "page" titles, and optional title with faraway page numbers
+% \VRef{label} => Section 2.7, \VPageref{label} => page 17
+% \VRef[Figure]{label} => Figure 3.4, \VPageref{label} => page 17
+\renewcommand{\reftextfaceafter}{\unskip}
+\renewcommand{\reftextfacebefore}{\unskip}
+\renewcommand{\reftextafter}{\unskip}
+\renewcommand{\reftextbefore}{\unskip}
+\renewcommand{\reftextfaraway}[1]{\unskip, p.~\pageref{#1}}
+\renewcommand{\reftextpagerange}[2]{\unskip, pp.~\pageref{#1}--\pageref{#2}}
+\newcommand{\VRef}[2][Section]{\ifx#1\@empty\else{#1}\nobreakspace\fi\vref{#2}}
+\newcommand{\VPageref}[2][page]{\ifx#1\@empty\else{#1}\nobreakspace\fi\pageref{#2}}
+% Go programming language
+\lstdefinelanguage{Golang}%
+  {morekeywords=[1]{package,import,func,type,struct,return,defer,panic, recover,select,var,const,iota,},%
+   morekeywords=[2]{string,uint,uint8,uint16,uint32,uint64,int,int8,int16, int32,int64,
+                bool,float32,float64,complex64,complex128,byte,rune,uintptr, error,interface},%
+   morekeywords=[3]{map,slice,make,new,nil,len,cap,copy,close,true,false, delete,append,real,imag,complex,chan,},%
+   morekeywords=[4]{for,break,continue,range,goto,switch,case,fallthrough,if, else,default,},%
+   morekeywords=[5]{Println,Printf,Error,},%
+   sensitive=true,%
+   morecomment=[l]{//},%
+   morecomment=[s]{/*}{*/},%
+   morestring=[b]',%
+   morestring=[b]",%
+   morestring=[s]{`}{`},%
+}
+% CFA based on ANSI C
+\lstdefinelanguage{CFA}[ANSI]{C}%
+{morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,trait,disable,dtype,enable,
+        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,otype,restrict,_Static_assert,
+        _Thread_local,throw,throwResume,try,},
+}%
+\lstset{
+language=CFA,
+columns=flexible,
+basicstyle=\sf\relsize{-1},
+tabsize=4,
+xleftmargin=\parindent,
+escapechar=@,
+mathescape=true,
+keepspaces=true,
+showstringspaces=false,
+showlines=true,
+}%
+\makeatletter
+% replace/adjust listings characters that look bad in sanserif
+\lst@CCPutMacro
+\lst@ProcessOther{"2D}{\lst@ttfamily{-{}}{{\ttfamily\upshape -}}} % replace minus
+\lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
+\lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
+\lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex
+\lst@ProcessLetter{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
+\lst@ProcessOther{"7E}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}} % replace tilde
+%\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde
+\@empty\z@\@empty
+\makeatother
+\input{common}
 \setcounter{secnumdepth}{3}     % number subsubsections
 …
 The command \lstinline@cfa@ is used to compile \CFA program(s).
 This command works like the GNU \lstinline@gcc@ command, e.g.:
+This command works like the GNU \lstinline@gcc@\index{gcc} command, e.g.:
 \begin{lstlisting}
 cfa [ gcc-options ] C/@{\CFA}@-files [ assembler/loader-files ]
 \end{lstlisting}
+The following additional option is available:
+By default, \CFA programs having the following \lstinline@gcc@ flags turned on:
+\begin{description}
+\item
+\hspace*{-4pt}\lstinline@-std=gnu99@
+The 1999 C standard plus GNU extensions.
+\end{description}
+The following new \CFA option is available:
 \begin{description}
 \item
 …
 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.:
 \begin{lstlisting}
 _147_483_648;                          // decimal constant
+`_`147`_`483`_`648;                            // decimal constant
 _ul;                                          // decimal unsigned long constant
 _377;                                          // octal constant
 …
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
+* int x, y;
+`* int x, y;`
 \end{lstlisting}
+&
 …
 The point of the new syntax is to allow returning multiple values from a routine~\cite{CLU,Galletly96}, e.g.:
 \begin{lstlisting}
 [ int o1, int o2, char o3 ] f( int i1, char i2, char i3 ) {
+`[ int o1, int o2, char o3 ]` f( int i1, char i2, char i3 ) {
         @\emph{routine body}@
+}
 …
 Because the value in the return variable is automatically returned when a \CFA routine terminates, the \lstinline@return@ statement \emph{does not} contain an expression, as in:
 \begin{lstlisting}
 [ int x ] f() {
+`[ int x ]` f() {
         ... x = 0; ... x = y; ...
         return; // implicitly return x
+        `return;` // implicitly return x
+}
 \end{lstlisting}
 …
 for example, the following is incorrect:
 \begin{lstlisting}
 * [ int x ] f () fp;            // routine name ``f'' is not allowed
+* [ int x ] f () fp;            // routine name "f" is not allowed
 \end{lstlisting}
 …
 \subsection{Type Nesting}
 C allows \Index{type nesting}, but the nested types are hoisted\index{type!hoisting} (refactored) into the enclosing scope.
+\CFA allows \Index{type nesting}, and type qualification of the nested types, where as C hoists\index{type!hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}l|l@{}}
 …
 int fred() {
         s.t.c = S.R;
         struct S.T t = { S.R, 1, 2 };
         enum S.C c;
         union S.T.U u;
+        s.t.c = `S.`R;  // type qualification
+        struct `S.`T t = { `S.`R, 1, 2 };
+        enum `S.`C c;
+        union `S.T.`U u;
+}
 \end{lstlisting}
 \end{tabular}
 \end{quote2}
+\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
+Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
+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.
+In the left example in C, types \lstinline@C@, \lstinline@U@ and \lstinline@T@ are implicitly hoisted outside of type \lstinline@S@ into the containing block scope.
+In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``\lstinline@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``\lstinline@::@''.
 …
 \begin{lstlisting}
 const unsigned int size = 10;
+int a[size];
+qsort( a, size );               // ascending order using built in ?<?
+{                                               // descending order by local redefinition
+        int ?<?( int a, int b ) { return a > b; } // nested routine
+        qsort( a, size );
+}
+\end{lstlisting}
+int ia[size];
+...                                             // assign values to array ia
+qsort( ia, size );              // sort ascending order using builtin ?<?
+{
+        `int ?<?( int x, int y ) { return x > y; }` // nested routine
+        qsort( ia, size );      // sort descending order by local redefinition
+}
+\end{lstlisting}
+Nested routines are not first-class, meaning a nested routine cannot be returned if it has references to variables in its enclosing blocks;
+the only exception is references to the external block of the translation unit, as these variables persist for the duration of the program.
+The following program in undefined in \CFA (and \lstinline@gcc@\index{gcc})
+\begin{lstlisting}
+[* [int]( int )] foo() {                // int (*foo())( int )
+        int `i` = 7;
+        int bar( int p ) {
+                `i` += 1;                                       // dependent on local variable
+                sout | `i` | endl;
+        }
+        return bar;                                     // undefined because of local dependence
+}
+int main() {
+        * [int](int) fp = foo();        // int (*fp)(int)
+    sout | fp( 3 ) | endl;
+}
+\end{lstlisting}
+because
+Currently, there are no \Index{lambda} expressions, i.e., unnamed routines because routine names are very important to properly select the correct routine.
 …
 \item
+Change: A struct is a scope in C++, not in C
+Rationale: Class scope is crucial to C++, and a struct is a class.
+Effect on original feature: Change to semantics of well-defined feature.
+Difficulty of converting: Semantic transformation.
+How widely used: C programs use struct extremely frequently, but the change is only noticeable when
+struct, enumeration, or enumerator names are referred to outside the struct. The latter is probably
+rare.
+Change: A struct is a scope in C++, not in C \\
+Rationale: Class scope is crucial to C++, and a struct is a class. \\
+Effect on original feature: Change to semantics of well-defined feature. \\
+Difficulty of converting: Semantic transformation. \\
+How widely used: C programs use struct extremely frequently, but the change is only noticeable when struct, enumeration, or enumerator names are referred to outside the struct.
+The latter is probably rare.
+\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
+Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
+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.
 \item
 …
 First the right-hand tuple is flattened and then the values are assigned individually.
 Flattening is also performed on tuple types.
 For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type lstinline@[ int, int, int, int ]@.
+For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type \lstinline@[ int, int, int, int ]@.
 A \newterm{structuring coercion} is the opposite of flattening;
 …
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 L1: for ( ... ) {
         L2: for ( ... ) {
                 L3: for ( ... ) {
                         ... break L1; ...
                         ... break L2; ...
                         ... break L3; // or break
+`L1:` for ( ... ) {
+        `L2:` for ( ... ) {
+                `L3:` for ( ... ) {
+                        ... break `L1`; ...
+                        ... break `L2`; ...
+                        ... break `L3`; // or break
+                }
+        }
 …
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 L1: for ( ... ) {
         L2: for ( ... ) {
                 L3: for ( ... ) {
                         ... continue L1; ...
                         ... continue L2; ...
                         ... continue L3; ...
+`L1`: for ( ... ) {
+        `L2`: for ( ... ) {
+                `L3`: for ( ... ) {
+                        ... continue `L1`; ...
+                        ... continue `L2`; ...
+                        ... continue `L3`; ...
+                }
 …
 \begin{lstlisting}
 switch ( i ) {
   case 1, 3, 5:
+  `case 1, 3, 5`:
         ...
   case 2, 4, 6:
+  `case 2, 4, 6`:
         ...
+}
 …
   case 1: case 3 : case 5:
         ...
   case 2: case 4 : case 6: /* even values */
+  case 2: case 4 : case 6:
         ...
+}
 …
 \begin{lstlisting}
 switch ( i ) {
   case 1~5
+  `case 1~5:`
         ...
   case 10~15
+  `case 10~15:`
         ...
+}
 …
+&
 \begin{lstlisting}
 // 1, 2, 3, 4, 5
 …
+\section{Generics }
+\section{Auto Type-Inferencing}
+Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization expression type.
+\begin{quote2}
+\begin{tabular}{@{}l@{\hspace{30pt}}ll@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CC}}        & \multicolumn{1}{c}{\lstinline@gcc@}\index{gcc} \\
+\begin{lstlisting}
+auto j = 3.0 * 4;
+int i;
+auto k = i;
+\end{lstlisting}
+&
+\begin{lstlisting}
+#define expr 3.0 * i
+typeof(expr) j = expr;
+int i;
+typeof(i) k = i;
+\end{lstlisting}
+&
+\begin{lstlisting}
+// use type of initialization expression
+// use type of primary variable
+\end{lstlisting}
+\end{tabular}
+\end{quote2}
+The two important capabilities are:
+\begin{itemize}
+\item
+preventing having to determine or write out long generic types,
+\item
+ensure secondary variables, related to a primary variable, always have the same type.
+\end{itemize}
+In \CFA, \lstinline@typedef@ provides a mechanism to alias long type names with short ones, both globally and locally, but not eliminate the use of the short name.
+\lstinline@gcc@ provides \lstinline@typeof@ to declare a secondary variable from a primary variable.
+\CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
+Only for overloaded routines with the same return type is variable type-inferencing possible.
+Finally, \lstinline@auto@ presents the programming problem of tracking down a type when the type is actually needed.
+For example, given
+\begin{lstlisting}
+auto j = `...`
+\end{lstlisting}
+and the need to write a routine to compute using \lstinline@j@
+\begin{lstlisting}
+void rtn( `...` parm );
+rtn( j );
+\end{lstlisting}
+A programmer must work backwards to determine the type of \lstinline@j@'s initialization expression, reconstructing the possibly long generic type-name.
+In this situation, having the type name or a short alias is very useful.
+There is also the conundrum in type inferencing of when to \emph{\Index{brand}} a type.
+That is, when is the type of the variable more important than the type of its initialization expression.
+For example, if a change is made in an initialization expression, it can cause hundreds or thousands of cascading type changes and/or errors.
+At some point, a programmer wants the type of the variable to remain constant and the expression to be in error when it changes.
+Given \lstinline@typedef@ and \lstinline@typeof@ in \CFA, and the strong need to use the type of left-hand side in inferencing, auto type-inferencing is not supported at this time.
+Should a significant need arise, this feature can be revisited.
+\section{Generics}
 \CFA supports parametric polymorphism to allow users to define generic functions and types.
 …
+\section{I/O Library}
+\label{s:IOLibrary}
+The goal for \CFA I/O is to make I/O as simple as possible for the general case, while fully supporting polmorphism and user defined types in a consistent way.
+The general case is printing out a sequence of variables separated by whitespace.
+\begin{lstlisting}
+int x = 0, y = 1, z = 2;
+sout | x | y | z | endl;
+cout << x << " " << y << " " << z << endl;
+\end{lstlisting}
+The \CC form takes almost twice as many characters.
+The logical-or operator is used because it is the lowest priority overloadable operator, other than assignment.
+Therefore, most output expressions do not require parenthesis.
+\begin{lstlisting}
+int x = 0, y = 1, z = 2;
+sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+\end{lstlisting}
+Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
+\begin{figure}
+\begin{lstlisting}[mathescape=off]
+#include <fstream>
+int main() {
+        char c;
+        short int si;
+        unsigned short int usi;
+        int i;
+        unsigned int ui;
+        long int li;
+        unsigned long int uli;
+        long long int lli;
+        unsigned long long int ulli;
+        float f;
+        double d;
+        long double ld;
+        float _Complex fc;
+        double _Complex dc;
+        long double _Complex ldc;
+        char s1[10], s2[10];
+        ifstream in;
+        open( &in, "read.data", "r" );
+        &in | &c
+                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli
+                | &f | &d | &ld
+                | &fc | &dc | &ldc
+                | str( s1 ) | str( s2, 10 );
+        sout | c | ' ' | endl
+                 | si | usi | i | ui | li | uli | lli | ulli | endl
+                 | f | d | ld | endl
+                 | f | "" | d | "" | ld | endl;
+        sepSet( sout, ", $" );
+        sout | fc | dc | ldc | endl
+                 | sepOn | s1 | sepOff | s2 | endl
+                 | s1 | "" | s2 | endl;
+}
+$ cat read.data
+A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
+$ a.out
+A
+2 3 4 5 6 7 8
+.1 1.2 1.3
+.11.21.3
+.1+2.3i, $1.1-2.3i, $1.1-2.3i
+, $abcxyz
+abcxyz
+\end{lstlisting}
+\end{figure}
+\section{Standard Library}
+\label{s:StandardLibrary}
+The goal of the \CFA standard-library is to wrap many of the existing C library-routines that are explicitly polymorphic into implicitly polymorphic versions.
+\subsection{malloc}
+\begin{lstlisting}
+forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( char fill );
+forall( otype T ) T * malloc( T * ptr, size_t size );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * calloc( size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );             // deprecated
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
+forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr );                                // remove when default value available
+\end{lstlisting}
+\subsection{ato/strto}
+\begin{lstlisting}
+int ato( const char * ptr );
+unsigned int ato( const char * ptr );
+long int ato( const char * ptr );
+unsigned long int ato( const char * ptr );
+long long int ato( const char * ptr );
+unsigned long long int ato( const char * ptr );
+float ato( const char * ptr );
+double ato( const char * ptr );
+long double ato( const char * ptr );
+float _Complex ato( const char * ptr );
+double _Complex ato( const char * ptr );
+long double _Complex ato( const char * ptr );
+int strto( const char * sptr, char ** eptr, int base );
+unsigned int strto( const char * sptr, char ** eptr, int base );
+long int strto( const char * sptr, char ** eptr, int base );
+unsigned long int strto( const char * sptr, char ** eptr, int base );
+long long int strto( const char * sptr, char ** eptr, int base );
+unsigned long long int strto( const char * sptr, char ** eptr, int base );
+float strto( const char * sptr, char ** eptr );
+double strto( const char * sptr, char ** eptr );
+long double strto( const char * sptr, char ** eptr );
+float _Complex strto( const char * sptr, char ** eptr );
+double _Complex strto( const char * sptr, char ** eptr );
+long double _Complex strto( const char * sptr, char ** eptr );
+\end{lstlisting}
+\subsection{bsearch/qsort}
+\begin{lstlisting}
+forall( otype T | { int ?<?( T, T ); } )
+T * bsearch( const T key, const T * arr, size_t dimension );
+forall( otype T | { int ?<?( T, T ); } )
+void qsort( const T * arr, size_t dimension );
+\end{lstlisting}
+\subsection{abs}
+\begin{lstlisting}
+char abs( char );
+extern "C" {
+int abs( int );         // use default C routine for int
+} // extern
+long int abs( long int );
+long long int abs( long long int );
+float abs( float );
+double abs( double );
+long double abs( long double );
+float _Complex abs( float _Complex );
+double _Complex abs( double _Complex );
+long double _Complex abs( long double _Complex );
+\end{lstlisting}
+\subsection{random}
+\begin{lstlisting}
+void randseed( long int s );
+char random();
+int random();
+unsigned int random();
+long int random();
+unsigned long int random();
+float random();
+double random();
+float _Complex random();
+double _Complex random();
+long double _Complex random();
+\end{lstlisting}
+\subsection{min/max/swap}
+\begin{lstlisting}
+forall( otype T | { int ?<?( T, T ); } )
+T min( const T t1, const T t2 );
+forall( otype T | { int ?>?( T, T ); } )
+T max( const T t1, const T t2 );
+forall( otype T )
+void swap( T * t1, T * t2 );
+\end{lstlisting}
+\section{Syntactic Anomalies}
+The number 0 and 1 are treated specially in \CFA, and can be redefined as variables.
+One syntactic anomaly is when a field in an structure is names 0 or 1:
+\begin{lstlisting}
+struct S {
+        int 0, 1;
+} s;
+\end{lstlisting}
+The problem occurs in accesing these fields using the selection operation ``\lstinline@.@'':
+\begin{lstlisting}
+s.0 = 0;        // ambiguity with floating constant .0
+s.1 = 1;        // ambiguity with floating constant .1
+\end{lstlisting}
+To make this work, a space is required after the field selection:
+\begin{lstlisting}
+`s.@\textvisiblespace@0` = 0;
+`s.@\textvisiblespace@1` = 1;
+\end{lstlisting}
+While this sytact is awkward, it is unlikely many programers will name fields of a structure 0 or 1.
+Like the \CC lexical problem with closing template-syntax, e.g, \lstinline@Foo<Bar<int`>>`@, this issue can be solved with a more powerful lexer/parser.
+There are several ambiguous cases with operator identifiers, e.g., \lstinline@int *?*?()@, where the string \lstinline@*?*?@ can be lexed as \lstinline@*@/\lstinline@?*?@ or \lstinline@*?@/\lstinline@*?@.
+Since it is common practise to put a unary operator juxtaposed to an identifier, e.g., \lstinline@*i@, users will be annoyed if they cannot do this with respect to operator identifiers.
+Even with this special hack, there are 5 general cases that cannot be handled.
+The first case is for the function-call identifier \lstinline@?()@:
+\begin{lstlisting}
+int *@\textvisiblespace@?()();  // declaration: space required after '*'
+*@\textvisiblespace@?()();              // expression: space required after '*'
+\end{lstlisting}
+Without the space, the string \lstinline@*?()@ is ambiguous without N character look ahead;
+it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument/parameter list.
+The 4 remaining cases occur in expressions:
+\begin{lstlisting}
+i++@\textvisiblespace@?i:0;             // space required before '?'
+i--@\textvisiblespace@?i:0;             // space required before '?'
+i@\textvisiblespace@?++i:0;             // space required after '?'
+i@\textvisiblespace@?--i:0;             // space required after '?'
+\end{lstlisting}
+In the first two cases, the string \lstinline@i++?@ is ambiguous, where this string can be lexed as \lstinline@i@ / \lstinline@++?@ or \lstinline@i++@ / \lstinline@?@;
+it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
+In the second two cases, the string \lstinline@?++x@ is ambiguous, where this string can be lexed as \lstinline@?++@ / \lstinline@x@ or \lstinline@?@ / y\lstinline@++x@;
+it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
 …
 task creates a type with implicit locking, separate stack, and a thread
 \subsection{Monitors}
 …
 \multicolumn{1}{c|}{\textbf{\CFA/\CC}} & \multicolumn{1}{c|}{\textbf{Go}} & \multicolumn{1}{c}{\textbf{Rust}}   \\
 \hline
 \begin{lstlisting}
+\begin{lstlisting}[boxpos=t]
 extern "C" {
 #include <sys/types.h>
 …
+}
 size_t fileSize( const char *path ) {
         stat s;
+        struct stat s;
         stat(path, &s);
         return s.st_size;
 …
 \end{lstlisting}
+&
 \begin{lstlisting}
+\begin{lstlisting}[boxpos=t]
 /*
 #cgo
 …
 \end{lstlisting}
+&
 \begin{lstlisting}
+\begin{lstlisting}[boxpos=t]
 use libc::{c_int, size_t};
-// The following declarations are
 // translated from sys/stat.h
 #[repr(C)]
 …
         ...
+}
 #[link(name = "libc")]
 extern {
 …
         buf: *mut stat_t) -> c_int;
+}
 fn fileSize(path: *const u8) -> size_t
+{
         unsafe {
         let mut buf: stat_t = uninit();
         stat(path, &mut buf);
         buf.st_size
+                let mut buf: stat_t = uninit();
+                stat(path, &mut buf);
+                buf.st_size
+        }
+}
 …
+\begin{comment}
 \subsubsection{Modules/Packages}
 …
+}
 \end{lstlisting}
+\end{comment}
 \subsubsection{Parallel Tasks}
 …
 \end{flushleft}
+\lstset{basicstyle=\sf\relsize{-1}}
 \subsection{Summary of Language Comparison}
 …
+\appendix
+\section{I/O Library}
+\label{s:IOLibrary}
+\index{input/output library}
+The goal for \CFA I/O is to make I/O as simple as possible for the general case, while fully supporting polmorphism and user defined types in a consistent way.
+The general case is printing out a sequence of variables separated by whitespace.
+\begin{quote2}
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{lstlisting}
+int x = 0, y = 1, z = 2;
+`sout` `|` x `|` y `|` z `| endl`;
+\end{lstlisting}
+&
+\begin{lstlisting}
+cout << x << " " << y << " " << z << endl;
+\end{lstlisting}
+\end{tabular}
+\end{quote2}
+The \CFA form is half as many characters, and is similar to Python I/O with respect to implicit separators.
+The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment.
+Therefore, fewer output expressions require parenthesis.
+\begin{quote2}
+\begin{tabular}{@{}ll@{}}
+\textbf{\CFA:}
+&
+\begin{lstlisting}
+sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+\end{lstlisting}
+\\
+\textbf{\CC:}
+&
+\begin{lstlisting}
+cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+\end{lstlisting}
+\end{tabular}
+\end{quote2}
+Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
+The implicit seperator\index{I/O separator} character (space/blank) is a separator not a terminator.
+The rules for implicitly adding the separator are:
+\begin{enumerate}
+\item
+A seperator does not appear at the start or end of a line.
+\begin{lstlisting}[belowskip=0pt]
+sout 1 | 2 | 3 | endl;
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+2 3
+\end{lstlisting}
+\item
+A seperator does not appear before or after a character literal or variable.
+\begin{lstlisting}
+sout | '1' | '2' | '3' | endl;
+\end{lstlisting}
+\item
+A seperator does not appear before or after a null (empty) C string
+\begin{lstlisting}
+sout | 1 | "" | 2 | "" | 3 | endl;
+\end{lstlisting}
+which is a local mechanism to disable insertion of the separator character.
+\item
+A seperator does not appear before a C string starting with the \Index{extended ASCII}\index{ASCII} characters: \lstinline[mathescape=off]@([{$£¥¿«@
+%$
+\begin{lstlisting}[mathescape=off]
+sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¿" | 7 | "x «" | 8 | endl;
+\end{lstlisting}
+%$
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+x (1 x [2 x {3 x $4 x £5 x ¥6 x ¿7 x «8
+\end{lstlisting}
+%$
+\item
+A seperator does not appear after a C string ending with the extended ASCII characters: \lstinline@,.:;!?)]}%¢»@
+\begin{lstlisting}[belowskip=0pt]
+sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
+         | 10 | "% x" | 11 | L"¢ x" | 12 | L"» x" | endl;
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+, x 2. x 3: x 4; x 5! x 6? x 7) x 8] x 9} x 10% x 11¢ 12»
+\end{lstlisting}
+\item
+A seperator does not appear before or after a C string begining/ending with the characters: \lstinline@\f\n\r\t\v\`'"@
+\begin{lstlisting}[belowskip=0pt]
+sout | "x '" | 1 | "' x \`" | 2 | "\` x \"" | 3 | "\" x" | endl;
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+x '1' x \`2\` x "3" x
+\end{lstlisting}
+\begin{lstlisting}[showtabs=true,aboveskip=0pt]
+sout | "x\t" | 1 | "\tx" | endl;
+x       1       x
+\end{lstlisting}
+\end{enumerate}
+The following \CC-style \Index{manipulator}s allow further control over implicit seperation.
+\begin{lstlisting}[mathescape=off,belowskip=0pt]
+sout | sepOn | 1 | 2 | 3 | sepOn | endl;        // separator at start of line
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+2 3
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sout | 1 | sepOff | 2 | 3 | endl;                       // turn off implicit separator temporarily
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+3
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sout | sepDisable | 1 | 2 | 3 | endl;           // turn off implicit separation, affects all subsequent prints
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sout | 1 | sepOn | 2 | 3 | endl;                        // turn on implicit separator temporarily
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+23
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
+sout | sepEnable | 1 | 2 | 3 | endl;            // turn on implicit separation, affects all subsequent prints
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+2 3
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
+sepSet( sout, ", $" );                                          // change separator from " " to ", $"
+sout | 1 | 2 | 3 | endl;
+\end{lstlisting}
+%$
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt]
+, $2, $3
+\end{lstlisting}
+%$
+\VRef[Figure]{f:ExampleIO} shows an example of input and output I/O in \CFA.
+\begin{figure}
+\begin{lstlisting}[mathescape=off]
+#include <fstream>
+int main() {
+        char c;                                                                                                         // basic types
+        short int si;
+        unsigned short int usi;
+        int i;
+        unsigned int ui;
+        long int li;
+        unsigned long int uli;
+        long long int lli;
+        unsigned long long int ulli;
+        float f;
+        double d;
+        long double ld;
+        float _Complex fc;
+        double _Complex dc;
+        long double _Complex ldc;
+        char s1[10], s2[10];
+        ifstream in;                                                                                            // create / open file
+        open( &in, "input.data", "r" );
+        &in | &c                                                                                                        // character
+                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli             // integral
+                | &f | &d | &ld                                                                                 // floating point
+                | &fc | &dc | &ldc                                                                              // floating-point complex
+                | cstr( s1 ) | cstr( s2, 10 );                                                  // C string, length unchecked and checked
+        sout | c | ' ' | endl                                                                           // character
+                 | si | usi | i | ui | li | uli | lli | ulli | endl             // integral
+                 | f | d | ld | endl                                                                    // floating point
+                 | fc | dc | ldc | endl;                                                                // complex
+        sout | endl;
+        sout | f | "" | d | "" | ld | endl                                                      // floating point without separator
+                 | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
+                 | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
+                 | s1 | "" | s2 | endl;                                                                 // C string withou separator
+        sout | endl;
+        sepSet( sout, ", $" );                                                                          // change separator, maximum of 15 characters
+        sout | f | d | ld | endl                                                                        // floating point without separator
+                 | fc | dc | ldc | endl                                                                 // complex without separator
+                 | s1 | s2 | endl;
+}
+$ cat input.data
+A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
+$ a.out
+A
+2 3 4 5 6 7 8
+.1 1.2 1.3
+.1+2.3i 1.1-2.3i 1.1-2.3i
+.11.21.3
+.1+2.3i1.1-2.3i1.1-2.3i
+ abcxyz
+abcxyz
+.1, $1.2, $1.3
+.1+2.3i, $1.1-2.3i, $1.1-2.3i
+abc, $xyz
+\end{lstlisting}
+\caption{Example I/O}
+\label{f:ExampleIO}
+\end{figure}
+\section{Standard Library}
+\label{s:StandardLibrary}
+The goal of the \CFA standard-library is to wrap many of the existing C library-routines that are explicitly polymorphic into implicitly polymorphic versions.
+\subsection{malloc}
+\begin{lstlisting}
+forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( char fill );
+forall( otype T ) T * malloc( T * ptr, size_t size );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * calloc( size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );             // deprecated
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
+forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr );                                // remove when default value available
+\end{lstlisting}
+\subsection{ato/strto}
+\begin{lstlisting}
+int ato( const char * ptr );
+unsigned int ato( const char * ptr );
+long int ato( const char * ptr );
+unsigned long int ato( const char * ptr );
+long long int ato( const char * ptr );
+unsigned long long int ato( const char * ptr );
+float ato( const char * ptr );
+double ato( const char * ptr );
+long double ato( const char * ptr );
+float _Complex ato( const char * ptr );
+double _Complex ato( const char * ptr );
+long double _Complex ato( const char * ptr );
+int strto( const char * sptr, char ** eptr, int base );
+unsigned int strto( const char * sptr, char ** eptr, int base );
+long int strto( const char * sptr, char ** eptr, int base );
+unsigned long int strto( const char * sptr, char ** eptr, int base );
+long long int strto( const char * sptr, char ** eptr, int base );
+unsigned long long int strto( const char * sptr, char ** eptr, int base );
+float strto( const char * sptr, char ** eptr );
+double strto( const char * sptr, char ** eptr );
+long double strto( const char * sptr, char ** eptr );
+float _Complex strto( const char * sptr, char ** eptr );
+double _Complex strto( const char * sptr, char ** eptr );
+long double _Complex strto( const char * sptr, char ** eptr );
+\end{lstlisting}
+\subsection{bsearch/qsort}
+\begin{lstlisting}
+forall( otype T | { int ?<?( T, T ); } )
+T * bsearch( const T key, const T * arr, size_t dimension );
+forall( otype T | { int ?<?( T, T ); } )
+void qsort( const T * arr, size_t dimension );
+\end{lstlisting}
+\subsection{abs}
+\begin{lstlisting}
+char abs( char );
+extern "C" {
+int abs( int );                         // use default C routine for int
+} // extern "C"
+long int abs( long int );
+long long int abs( long long int );
+float abs( float );
+double abs( double );
+long double abs( long double );
+float _Complex abs( float _Complex );
+double _Complex abs( double _Complex );
+long double _Complex abs( long double _Complex );
+\end{lstlisting}
+\subsection{floor/ceil}
+\begin{lstlisting}
+float floor( float );
+extern "C" {
+double floor( double );         // use C routine for double
+} // extern "C"
+long double floor( long double );
+float ceil( float );
+extern "C" {
+double ceil( double );          // use C routine for double
+} // extern "C"
+long double ceil( long double );
+\end{lstlisting}
+\subsection{random}
+\begin{lstlisting}
+void rand48seed( long int s );
+char rand48();
+int rand48();
+unsigned int rand48();
+long int rand48();
+unsigned long int rand48();
+float rand48();
+double rand48();
+float _Complex rand48();
+double _Complex rand48();
+long double _Complex rand48();
+\end{lstlisting}
+\subsection{min/max/swap}
+\begin{lstlisting}
+forall( otype T | { int ?<?( T, T ); } )
+T min( const T t1, const T t2 );
+forall( otype T | { int ?>?( T, T ); } )
+T max( const T t1, const T t2 );
+forall( otype T )
+void swap( T * t1, T * t2 );
+\end{lstlisting}
+\section{Rational Numbers}
+\label{s:RationalNumbers}
+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.
+When creating and computing with rational numbers, results are constantly reduced to keep the numerator and denominator as small as possible.
+\begin{lstlisting}
+// implementation
+struct Rational {
+        long int numerator, denominator;                                        // invariant: denominator > 0
+}; // Rational
+// constants
+extern struct Rational 0;
+extern struct Rational 1;
+// constructors
+Rational rational();
+Rational rational( long int n );
+Rational rational( long int n, long int d );
+// getter/setter for numerator/denominator
+long int numerator( Rational r );
+long int numerator( Rational r, long int n );
+long int denominator( Rational r );
+long int denominator( Rational r, long int d );
+// comparison
+int ?==?( Rational l, Rational r );
+int ?!=?( Rational l, Rational r );
+int ?<?( Rational l, Rational r );
+int ?<=?( Rational l, Rational r );
+int ?>?( Rational l, Rational r );
+int ?>=?( Rational l, Rational r );
+// arithmetic
+Rational -?( Rational r );
+Rational ?+?( Rational l, Rational r );
+Rational ?-?( Rational l, Rational r );
+Rational ?*?( Rational l, Rational r );
+Rational ?/?( Rational l, Rational r );
+// conversion
+double widen( Rational r );
+Rational narrow( double f, long int md );
+// I/O
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, Rational );
+\end{lstlisting}
 \bibliographystyle{plain}
 \bibliography{/usr/local/bibliographies/pl.bib}
+\bibliography{cfa}

src/CodeGen/CodeGenerator.cc

-                      r3aba311
+                      r37218fc
         void CodeGenerator::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 assert( false );
+                assert( false && "UntypedOffsetofExpr should not reach code generation" );
+        }
 …
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
+        }
+        void CodeGenerator::visit( OffsetPackExpr *offsetPackExpr ) {
+                assert( false && "OffsetPackExpr should not reach code generation" );
+        }

src/CodeGen/CodeGenerator.h

r3aba311	r37218fc
65	65	virtual void visit( UntypedOffsetofExpr *offsetofExpr );
66	66	virtual void visit( OffsetofExpr *offsetofExpr );
	67	virtual void visit( OffsetPackExpr *offsetPackExpr );
67	68	virtual void visit( LogicalExpr *logicalExpr );
68	69	virtual void visit( ConditionalExpr *conditionalExpr );

src/GenPoly/Box.cc

-                      r3aba311
+                      r37218fc
 #include "FindFunction.h"
 #include "ScopedMap.h"
+#include "ScopedSet.h"
 #include "ScrubTyVars.h"
 …
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
+                /// Key for a unique concrete type; generic base type paired with type parameter list
+                struct ConcreteType {
+                        ConcreteType() : base(NULL), params() {}
+                        ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); }
+                        ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
+                /// Abstracts type equality for a list of parameter types
+                struct TypeList {
+                        TypeList() : params() {}
+                        TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }
+                        TypeList( std::list< Type* > &&_params ) : params( _params ) {}
+                        TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }
+                        TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}
                         /// Extracts types from a list of TypeExpr*
                         ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
+                        TypeList( const std::list< TypeExpr* >& _params ) : params() {
                                 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
                                         params.push_back( (*param)->get_type()->clone() );
 …
+                        }
                         ConcreteType& operator= (const ConcreteType& that) {
+                        TypeList& operator= ( const TypeList &that ) {
                                 deleteAll( params );
                                 params.clear();
-                                base = that.base;
                                 cloneAll( that.params, params );
 …
+                        }
+                        ~ConcreteType() { deleteAll( params ); }
+                        bool operator== (const ConcreteType& that) const {
+                                if ( base != that.base ) return false;
+                        TypeList& operator= ( TypeList &&that ) {
+                                deleteAll( params );
+                                params = std::move( that.params );
+                                return *this;
+                        }
+                        ~TypeList() { deleteAll( params ); }
+                        bool operator== ( const TypeList& that ) const {
+                                if ( params.size() != that.params.size() ) return false;
                                 SymTab::Indexer dummy;
-                                if ( params.size() != that.params.size() ) return false;
                                 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
                                         if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
 …
+                        }
-                        AggregateDecl *base;        ///< Base generic type
                         std::list< Type* > params;  ///< Instantiation parameters
                 };
                 /// Maps a concrete type to the some value, accounting for scope
                 template< typename Value >
+                /// Maps a key and a TypeList to the some value, accounting for scope
+                template< typename Key, typename Value >
                 class InstantiationMap {
+                        /// Information about a specific instantiation of a generic type
+                        struct Instantiation {
+                                ConcreteType key;  ///< Instantiation parameters for this type
+                                Value *value;      ///< Value for this instantiation
+                                Instantiation() : key(), value(0) {}
+                                Instantiation(const ConcreteType &_key, Value *_value) : key(_key), value(_value) {}
+                        };
+                        /// Map of generic types to instantiations of them
+                        typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
+                        std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
+                        /// Wraps value for a specific (Key, TypeList) combination
+                        typedef std::pair< TypeList, Value* > Instantiation;
+                        /// List of TypeLists paired with their appropriate values
+                        typedef std::vector< Instantiation > ValueList;
+                        /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values
+                        typedef ScopedMap< Key*, ValueList > InnerMap;
+                        InnerMap instantiations;  ///< instantiations
                 public:
                         /// Starts a new scope
+                        void beginScope() {
+                                Scope scope;
+                                scopes.push_back(scope);
+                        }
+                        void beginScope() { instantiations.beginScope(); }
                         /// Ends a scope
+                        void endScope() {
+                                scopes.pop_back();
+                        }
+                        /// Default constructor initializes with one scope
+                        InstantiationMap() { beginScope(); }
+//              private:
+                        /// Gets the value for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
+                        /// Returns NULL on none such.
+                        Value *lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
+                                ConcreteType key(generic, params);
+                                // scan scopes from innermost out
+                                for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
+                                        // skip scope if no instantiations of this generic type
+                                        typename Scope::const_iterator insts = scope->find( generic );
+                                        if ( insts == scope->end() ) continue;
+                                        // look through instantiations for matches to concrete type
+                                        for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
+                                                if ( inst->key == key ) return inst->value;
+                        void endScope() { instantiations.endScope(); }
+                        /// Gets the value for the (key, typeList) pair, returns NULL on none such.
+                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
+                                TypeList typeList( params );
+                                // scan scopes for matches to the key
+                                for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
+                                        for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {
+                                                if ( inst->first == typeList ) return inst->second;
+                                        }
+                                }
                                 // no matching instantiation found
+                                // no matching instantiations found
                                 return 0;
+                        }
+                public:
+//                      StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); }
+//                      UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); }
+//              private:
+                        /// Adds a value for a concrete type to the current scope
+                        void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, Value *value ) {
+                                ConcreteType key(generic, params);
+                                scopes.back()[generic].push_back( Instantiation( key, value ) );
+                        }
+//              public:
+//                      void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); }
+//                      void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); }
+                        /// Adds a value for a (key, typeList) pair to the current scope
+                        void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
+                                instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
+                        }
                 };
 …
                         virtual void doEndScope();
                   private:
-                        /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it
-                        Expression *makeOffsetArray( StructInstType *type );
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
 …
                         ObjectDecl *makeTemporary( Type *type );
+                        std::map< std::string, DeclarationWithType *> assignOps;
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;
+                        ScopedMap< std::string, DeclarationWithType* > adapters;
+                        std::map< std::string, DeclarationWithType *> assignOps;     ///< Currently known type variable assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
+                        ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
                         DeclarationWithType *retval;
                         bool useRetval;
 …
                 };
+                /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well
+                /// * Moves polymorphic returns in function types to pointer-type parameters
+                /// * adds type size and assertion parameters to parameter lists
                 class Pass2 : public PolyMutator {
                   public:
 …
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
                   private:
                         void addAdapters( FunctionType *functionType );
 …
                 class GenericInstantiator : public DeclMutator {
                         /// Map of (generic type, parameter list) pairs to concrete type instantiations
                         InstantiationMap< AggregateDecl > instantiations;
+                        InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
                         /// Namer for concrete types
                         UniqueName typeNamer;
 …
                 };
+                /// Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference;
+                /// also fixes offsetof expressions.
+                class MemberExprFixer : public PolyMutator {
+                  public:
+                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
+                /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
+                /// * Calculates polymorphic offsetof expressions from offset array
+                /// * Inserts dynamic calculation of polymorphic type layouts where needed
+                class PolyGenericCalculator : public PolyMutator {
+                public:
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
 …
                         virtual Type *mutate( FunctionType *funcType );
                         virtual Expression *mutate( MemberExpr *memberExpr );
+                        virtual Expression *mutate( SizeofExpr *sizeofExpr );
+                        virtual Expression *mutate( AlignofExpr *alignofExpr );
                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
+                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
+                        virtual void doBeginScope();
+                        virtual void doEndScope();
+                private:
+                        /// Makes a new variable in the current scope with the given name, type & optional initializer
+                        ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 );
+                        /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns
+                        bool findGeneric( Type *ty );
+                        /// adds type parameters to the layout call; will generate the appropriate parameters if needed
+                        void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
+                        ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
+                        ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                 };
 …
                 Pass2 pass2;
                 GenericInstantiator instantiator;
                 MemberExprFixer memberFixer;
+                PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
 …
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-//              instantiateGeneric( translationUnit );
                 instantiator.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, memberFixer );
+                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
+        }
 …
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         // if this is a polymorphic assignment function, put it in the map for this scope
+                        // if this is a assignment function, put it in the map for this scope
                         if ( Type *assignedType = isAssignment( functionDecl ) ) {
                                 if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) {
 …
+                }
-                Expression *Pass1::makeOffsetArray( StructInstType *ty ) {
-                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
-                        // make a new temporary array
-                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                        std::stringstream lenGen;
-                        lenGen << baseMembers.size();
-                        ConstantExpr *lenExpr = new ConstantExpr( Constant( offsetType->clone(), lenGen.str() ) );
-                        ObjectDecl *arrayTemp = makeTemporary( new ArrayType( Type::Qualifiers(), offsetType, lenExpr, false, false ) );
-                        // build initializer list for temporary
-                        std::list< Initializer* > inits;
-                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
-                                DeclarationWithType *memberDecl;
-                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
-                                        memberDecl = origMember->clone();
-                                } else {
-                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                }
-                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
+                        }
-                        arrayTemp->set_init( new ListInit( inits ) );
-                        // return variable pointing to temporary
-                        return new VariableExpr( arrayTemp );
+                }
                 void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
                         Type *polyBase = hasPolyBase( parmType, exprTyVars );
 …
                                 if ( dynamic_cast< StructInstType* >( polyBase ) ) {
                                         if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
+                                                arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
+                                                arg++;
+                                                // zero-length arrays are forbidden by C, so don't pass offset for empty struct
+                                                if ( ! argBaseStructType->get_baseStruct()->get_members().empty() ) {
+                                                        arg = appExpr->get_args().insert( arg, new OffsetPackExpr( argBaseStructType->clone() ) );
+                                                        arg++;
+                                                }
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct" );
 …
                                         return;
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
+                                        // VariableExpr and MemberExpr are lvalues
+                                        arg = new AddressExpr( arg );
+                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
+                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
+                                        } else {
+                                                arg = new AddressExpr( arg );
+                                        }
                                 } else {
                                         // use type computed in unification to declare boxed variables
 …
                         } // for
+                }
                 FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
 …
                                         std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
                                         for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
+                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype)
+                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
+                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
+                                                DeclarationWithType *actualDecl = asserts.front();
+                                                TypeInstType *actualType = isTypeInstAssignment( actualDecl );
+                                                assert( actualType && "First assertion of type with assertions should be assignment operator" );
+                                                // Add appropriate mapping to assignment expression environment
                                                 TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
                                                 assert( formalTypeExpr && "type parameters must be type expressions" );
                                                 Type *formalType = formalTypeExpr->get_type();
+                                                assignExpr->get_env()->add( actualType->get_name(), formalType );
+                                                assignExpr->get_env()->add( (*forallIt)->get_name(), formalType );
+                                                // skip types with no assign op (ftype/dtype)
+                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue;
+                                                // find assignment operator for formal type
                                                 DeclarationWithType *assertAssign = 0;
                                                 if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
 …
+                                                        }
+                                                }
+                                                // add inferred parameter for field assignment operator to assignment expression
+                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
+                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
+                                                DeclarationWithType *actualDecl = asserts.front();
                                                 assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
                                                         = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
 …
                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
-//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
                         for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *sizeParm, *alignParm;
 …
                                         ++last;
+                                        if ( dynamic_cast< StructInstType* >( polyBase ) ) {
+                                                offsetParm = newPtr.clone();
+                                                offsetParm->set_name( offsetofName( polyBase ) );
+                                                last = funcType->get_parameters().insert( last, offsetParm );
+                                                ++last;
+                                        if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyBase ) ) {
+                                                // NOTE zero-length arrays are illegal in C, so empty structs have no offset array
+                                                if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) {
+                                                        offsetParm = newPtr.clone();
+                                                        offsetParm->set_name( offsetofName( polyBase ) );
+                                                        last = funcType->get_parameters().insert( last, offsetParm );
+                                                        ++last;
+                                                }
+                                        }
 …
                 template< typename DeclClass >
                 DeclClass * MemberExprFixer::handleDecl( DeclClass *decl, Type *type ) {
+                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( type, scopeTyVars );
 …
+                }
                 ObjectDecl * MemberExprFixer::mutate( ObjectDecl *objectDecl ) {
+                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
                         return handleDecl( objectDecl, objectDecl->get_type() );
+                }
                 DeclarationWithType * MemberExprFixer::mutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
                         return handleDecl( functionDecl, functionDecl->get_functionType() );
+                }
                 TypedefDecl * MemberExprFixer::mutate( TypedefDecl *typedefDecl ) {
+                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
                         return handleDecl( typedefDecl, typedefDecl->get_base() );
+                }
                 TypeDecl * MemberExprFixer::mutate( TypeDecl *typeDecl ) {
+                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
+                }
                 Type * MemberExprFixer::mutate( PointerType *pointerType ) {
+                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
 …
+                }
                 Type * MemberExprFixer::mutate( FunctionType *functionType ) {
+                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
                         TyVarMap oldtyVars = scopeTyVars;
+                        makeTyVarMap( functionType, scopeTyVars );
+                        Type *ret = Mutator::mutate( functionType );
+                        makeTyVarMap( funcType, scopeTyVars );
+                        // make sure that any type information passed into the function is accounted for
+                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) {
+                                // condition here duplicates that in Pass2::mutate( FunctionType* )
+                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), scopeTyVars );
+                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
+                                        knownLayouts.insert( sizeofName( polyBase ) );
+                                }
+                        }
+                        Type *ret = Mutator::mutate( funcType );
                         scopeTyVars = oldtyVars;
 …
+                }
                 Statement *MemberExprFixer::mutate( DeclStmt *declStmt ) {
+                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( isPolyType( objectDecl->get_type(), scopeTyVars ) ) {
+                                if ( findGeneric( objectDecl->get_type() ) ) {
                                         // change initialization of a polymorphic value object
                                         // to allocate storage with alloca
 …
+                }
                 Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) {
+                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
                         Expression *expr = Mutator::mutate( memberExpr );
 …
                         Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
+                        findGeneric( objectType ); // ensure layout for this type is available
                         Expression *newMemberExpr = 0;
 …
+                }
+                Expression *MemberExprFixer::mutate( OffsetofExpr *offsetofExpr ) {
+                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
+                        ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        return newObj;
+                }
+                void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) {
+                        for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
+                                if ( findGeneric( *param ) ) {
+                                        // push size/align vars for a generic parameter back
+                                        layoutCall->get_args().push_back( new NameExpr( sizeofName( *param ) ) );
+                                        layoutCall->get_args().push_back( new NameExpr( alignofName( *param ) ) );
+                                } else {
+                                        layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
+                                        layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) );
+                                }
+                        }
+                }
+                /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list
+                bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) {
+                        bool hasDynamicLayout = false;
+                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
+                        std::list< Expression* >::const_iterator typeParam = typeParams.begin();
+                        for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
+                                // skip non-otype parameters
+                                if ( (*baseParam)->get_kind() != TypeDecl::Any ) continue;
+                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
+                                assert( typeExpr && "all otype parameters should be type expressions" );
+                                Type *type = typeExpr->get_type();
+                                out.push_back( type );
+                                if ( isPolyType( type ) ) hasDynamicLayout = true;
+                        }
+                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
+                        return hasDynamicLayout;
+                }
+                bool PolyGenericCalculator::findGeneric( Type *ty ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                                // duplicate logic from isPolyType()
+                                if ( env ) {
+                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                                return findGeneric( newType );
+                                        } // if
+                                } // if
+                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
+                                        // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
+                                        return true;
+                                }
+                                return false;
+                        } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
+                                // check if this type already has a layout generated for it
+                                std::string sizeName = sizeofName( ty );
+                                if ( knownLayouts.find( sizeName ) != knownLayouts.end() ) return true;
+                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
+                                std::list< Type* > otypeParams;
+                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false;
+                                // insert local variables for layout and generate call to layout function
+                                knownLayouts.insert( sizeName );  // done early so as not to interfere with the later addition of parameters to the layout call
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                                int n_members = structTy->get_baseStruct()->get_members().size();
+                                if ( n_members == 0 ) {
+                                        // all empty structs have the same layout - size 1, align 1
+                                        makeVar( sizeName, layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( alignofName( ty ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
+                                } else {
+                                        ObjectDecl *sizeVar = makeVar( sizeName, layoutType );
+                                        ObjectDecl *alignVar = makeVar( alignofName( ty ), layoutType->clone() );
+                                        ObjectDecl *offsetVar = makeVar( offsetofName( ty ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
+                                        // generate call to layout function
+                                        UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( "__layoutof_" + structTy->get_baseStruct()->get_name() ) );
+                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
+                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
+                                        layoutCall->get_args().push_back( new VariableExpr( offsetVar ) );
+                                        addOtypeParamsToLayoutCall( layoutCall, otypeParams );
+                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                }
+                                return true;
+                        } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
+                                // check if this type already has a layout generated for it
+                                std::string sizeName = sizeofName( ty );
+                                if ( knownLayouts.find( sizeName ) != knownLayouts.end() ) return true;
+                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
+                                std::list< Type* > otypeParams;
+                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false;
+                                // insert local variables for layout and generate call to layout function
+                                knownLayouts.insert( sizeName );  // done early so as not to interfere with the later addition of parameters to the layout call
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                                ObjectDecl *sizeVar = makeVar( sizeName, layoutType );
+                                ObjectDecl *alignVar = makeVar( alignofName( ty ), layoutType->clone() );
+                                // generate call to layout function
+                                UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( "__layoutof_" + unionTy->get_baseUnion()->get_name() ) );
+                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
+                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
+                                addOtypeParamsToLayoutCall( layoutCall, otypeParams );
+                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                return true;
+                        }
+                        return false;
+                }
+                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
+                        Type *ty = sizeofExpr->get_type();
+                        if ( findGeneric( ty ) ) {
+                                Expression *ret = new NameExpr( sizeofName( ty ) );
+                                delete sizeofExpr;
+                                return ret;
+                        }
+                        return sizeofExpr;
+                }
+                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
+                        Type *ty = alignofExpr->get_type();
+                        if ( findGeneric( ty ) ) {
+                                Expression *ret = new NameExpr( alignofName( ty ) );
+                                delete alignofExpr;
+                                return ret;
+                        }
+                        return alignofExpr;
+                }
+                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
                         // mutate, exiting early if no longer OffsetofExpr
                         Expression *expr = Mutator::mutate( offsetofExpr );
 …
                         // only mutate expressions for polymorphic structs/unions
                         Type *ty = isPolyType( offsetofExpr->get_type(), scopeTyVars );
                         if ( ! ty ) return offsetofExpr;
+                        Type *ty = offsetofExpr->get_type();
+                        if ( ! findGeneric( ty ) ) return offsetofExpr;
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
                                 // replace offsetof expression by index into offset array
 …
+                }
+                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
+                        StructInstType *ty = offsetPackExpr->get_type();
+                        Expression *ret = 0;
+                        if ( findGeneric( ty ) ) {
+                                // pull offset back from generated type information
+                                ret = new NameExpr( offsetofName( ty ) );
+                        } else {
+                                std::string offsetName = offsetofName( ty );
+                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
+                                        // use the already-generated offsets for this type
+                                        ret = new NameExpr( offsetName );
+                                } else {
+                                        knownOffsets.insert( offsetName );
+                                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
+                                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                                        // build initializer list for offset array
+                                        std::list< Initializer* > inits;
+                                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
+                                                DeclarationWithType *memberDecl;
+                                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
+                                                        memberDecl = origMember->clone();
+                                                } else {
+                                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                                }
+                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
+                                        }
+                                        // build the offset array and replace the pack with a reference to it
+                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
+                                                        new ListInit( inits ) );
+                                        ret = new VariableExpr( offsetArray );
+                                }
+                        }
+                        delete offsetPackExpr;
+                        return ret;
+                }
+                void PolyGenericCalculator::doBeginScope() {
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
+                }
+                void PolyGenericCalculator::doEndScope() {
+                        knownLayouts.endScope();
+                        knownOffsets.beginScope();
+                }
 ////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////

src/GenPoly/ScopedMap.h

-                      r3aba311
+                      r37218fc
 #define _SCOPEDMAP_H
+#include <cassert>
 #include <iterator>
 #include <map>
 …
                 void endScope() {
                         scopes.pop_back();
+                        assert( ! scopes.empty() );
+                }
 …
                         return end();
+                }
+                const_iterator find( const Key &key ) const { return const_iterator( find( key ) ); }
+                const_iterator find( const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) );
+                }
                 /// Finds the given key in the outermost scope inside the given scope where it occurs
 …
                         return end();
+                }
+                const_iterator findNext( const_iterator &it, const Key &key ) const { return const_iterator( findNext( it, key ) ); }
+                const_iterator findNext( const_iterator &it, const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findNext( it, key ) );
+                }
                 /// Inserts the given key-value pair into the outermost scope
 …
+                }
                 std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
+                Value& operator[] ( const Key &key ) {
+                        iterator slot = find( key );
+                        if ( slot != end() ) return slot->second;
+                        return insert( key, Value() ).first->second;
+                }
         };
 } // namespace GenPoly

src/InitTweak/InitModel.h

r3aba311	r37218fc
75	75	void visit( UntypedOffsetofExpr * ) { throw 0; }
76	76	void visit( OffsetofExpr * ) { throw 0; }
	77	void visit( OffsetPackExpr * ) { throw 0; }
77	78	void visit( AttrExpr * ) { throw 0; }
78	79	void visit( LogicalExpr * ) { throw 0; }

src/Parser/ExpressionNode.cc

-                      r3aba311
+                      r37218fc
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Mar 13 12:34:38 2016
 // Update Count     : 272
+// Last Modified On : Fri Apr  8 15:43:05 2016
+// Update Count     : 296
 //
 …
 #include "ParseNode.h"
+#include "TypeData.h"
 #include "SynTree/Constant.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Declaration.h"
 #include "Common/UnimplementedError.h"
 #include "parseutility.h"
 …
+}
+CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {}
+CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {}
+CompoundLiteralNode::~CompoundLiteralNode() {
+        delete kids;
+        delete type;
+}
+CompoundLiteralNode *CompoundLiteralNode::clone() const {
+        return new CompoundLiteralNode( *this );
+}
+void CompoundLiteralNode::print( std::ostream &os, int indent ) const {
+        os << string( indent,' ' ) << "CompoundLiteralNode:" << endl;
+        os << string( indent + 2, ' ' ) << "type:" << endl;
+        if ( type != 0 )
+                type->print( os, indent + 4 );
+        os << string( indent + 2, ' ' ) << "initialization:" << endl;
+        if ( kids != 0 )
+                kids->printList( os, indent + 4 );
+}
+void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const {
+        os << "( ";
+        if ( type ) type->print( os );
+        os << ", ";
+        if ( kids ) kids->printOneLine( os );
+        os << ") ";
+}
+Expression *CompoundLiteralNode::build() const {
+        Declaration * newDecl = type->build();                          // compound literal type
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() );
+        // these types do not have associated type information
+        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), kids->build() );
+        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() );
+        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() );
+        } else {
+                assert( false );
+        } // if
+}
 ExpressionNode *flattenCommas( ExpressionNode *list ) {
         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {

src/Parser/ParseNode.h

-                      r3aba311
+                      r37218fc
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Mon Apr 04 17:04:22 2016
 // Update Count     : 190
+// Last Modified On : Mon Apr 11 11:50:52 2016
+// Update Count     : 205
 //
 …
 };
+class CompoundLiteralNode : public ExpressionNode {
+  public:
+        CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
+        CompoundLiteralNode( const CompoundLiteralNode &type );
+        ~CompoundLiteralNode();
+        virtual CompoundLiteralNode *clone() const;
+        DeclarationNode *get_type() const { return type; }
+        CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
+        InitializerNode *get_initializer() const { return kids; }
+        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
+        void print( std::ostream &, int indent = 0 ) const;
+        void printOneLine( std::ostream &, int indent = 0 ) const;
+        virtual Expression *build() const;
+  private:
+        DeclarationNode *type;
+        InitializerNode *kids;
+};
 template< typename SynTreeType, typename NodeType >
 void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {

src/Parser/parser.cc

r3aba311	r37218fc
5180	5180	/* Line 1806 of yacc.c */
5181	5181	#line 374 "parser.yy"
5182		{ (yyval.en) = 0; }
	5182	{ (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
5183	5183	break;
5184	5184

src/Parser/parser.yy

-                      r3aba311
+                      r37218fc
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 24 16:16:16 2016
 // Update Count     : 1498
+// Last Modified On : Fri Apr  8 16:21:55 2016
+// Update Count     : 1508
 //
 …
                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
                 { $$ = 0; }
+                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
         | postfix_expression '{' argument_expression_list '}' // CFA
+                {

src/ResolvExpr/AlternativeFinder.cc

-                      r3aba311
+                      r37218fc
+        }
+        void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) {
+                alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
+        }
         void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
                 // assume no polymorphism

src/ResolvExpr/AlternativeFinder.h

r3aba311	r37218fc
59	59	virtual void visit( UntypedOffsetofExpr *offsetofExpr );
60	60	virtual void visit( OffsetofExpr *offsetofExpr );
	61	virtual void visit( OffsetPackExpr *offsetPackExpr );
61	62	virtual void visit( AttrExpr *attrExpr );
62	63	virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/AddVisit.h

-                      r3aba311
+                      r37218fc
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 16:14:32 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Tue Jul 14 12:26:17 2015
 // Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Apr  7 14:42:21 2016
+// Update Count     : 5
 //
 …
         template< typename Visitor >
-        inline void addVisitStatement( Statement *stmt, Visitor &visitor ) {
-                maybeAccept( stmt, visitor );
-///   if ( ! declsToAdd.empty() ) {
-///     CompoundStmt *compound = new CompoundStmt( noLabels );
-///     compound->get_kids().push_back( stmt );
-///     addDecls( declsToAdd, compound->get_kids(), compound->get_kids().end() );
-///   }
+        }
-        template< typename Visitor >
         inline void addVisit(CompoundStmt *compoundStmt, Visitor &visitor) {
                 addVisitStatementList( compoundStmt->get_kids(), visitor );
+        }
-        template< typename Visitor >
-        inline void addVisit(IfStmt *ifStmt, Visitor &visitor) {
-                addVisitStatement( ifStmt->get_thenPart(), visitor );
-                addVisitStatement( ifStmt->get_elsePart(), visitor );
-                maybeAccept( ifStmt->get_condition(), visitor );
+        }
-        template< typename Visitor >
-        inline void addVisit(WhileStmt *whileStmt, Visitor &visitor) {
-                addVisitStatement( whileStmt->get_body(), visitor );
-                maybeAccept( whileStmt->get_condition(), visitor );
+        }
-        template< typename Visitor >
-        inline void addVisit(ForStmt *forStmt, Visitor &visitor) {
-                addVisitStatement( forStmt->get_body(), visitor );
-                acceptAll( forStmt->get_initialization(), visitor );
-                maybeAccept( forStmt->get_condition(), visitor );
-                maybeAccept( forStmt->get_increment(), visitor );
+        }
 …
+        }
+        template< typename Visitor >
+        inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
+                addVisitStatementList( caseStmt->get_statements(), visitor );
+                maybeAccept( caseStmt->get_condition(), visitor );
+        }
+        template< typename Visitor >
+        inline void addVisit(CatchStmt *cathStmt, Visitor &visitor) {
+                addVisitStatement( cathStmt->get_body(), visitor );
+                maybeAccept( cathStmt->get_decl(), visitor );
+        }
+        // template< typename Visitor >
+        // inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
+        //      addVisitStatementList( caseStmt->get_statements(), visitor );
+        //      maybeAccept( caseStmt->get_condition(), visitor );
+        // }
 } // namespace SymTab

src/SymTab/Indexer.cc

-                      r3aba311
+                      r37218fc
                 maybeAccept( offsetofExpr->get_type(), *this );
                 maybeAccept( offsetofExpr->get_member(), *this );
+        }
+        void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
+                acceptAllNewScope( offsetPackExpr->get_results(), *this );
+                maybeAccept( offsetPackExpr->get_type(), *this );
+        }

src/SymTab/Indexer.h

r3aba311	r37218fc
59	59	virtual void visit( UntypedOffsetofExpr *offsetofExpr );
60	60	virtual void visit( OffsetofExpr *offsetofExpr );
	61	virtual void visit( OffsetPackExpr *offsetPackExpr );
61	62	virtual void visit( AttrExpr *attrExpr );
62	63	virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/Validate.cc

-                      r3aba311
+                      r37218fc
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:31:39 2016
 // Update Count     : 226
+// Last Modified On : Thu Apr  7 16:45:30 2016
+// Update Count     : 243
 //
 …
 #include <list>
 #include <iterator>
+#include "Common/utility.h"
+#include "Common/UniqueName.h"
 #include "Validate.h"
 #include "SynTree/Visitor.h"
 #include "SynTree/Mutator.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
 #include "SynTree/Statement.h"
 #include "SynTree/TypeSubstitution.h"
 …
 #include "FixFunction.h"
 // #include "ImplementationType.h"
+#include "Common/utility.h"
+#include "Common/UniqueName.h"
+#include "GenPoly/DeclMutator.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
 …
                 virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( WhileStmt *whileStmt );
-                virtual void visit( ForStmt *forStmt );
                 virtual void visit( SwitchStmt *switchStmt );
                 virtual void visit( ChooseStmt *chooseStmt );
+                virtual void visit( CaseStmt *caseStmt );
+                virtual void visit( CatchStmt *catchStmt );
+                // virtual void visit( CaseStmt *caseStmt );
           private:
                 HoistStruct();
 …
                 virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( WhileStmt *whileStmt );
-                virtual void visit( ForStmt *forStmt );
                 virtual void visit( SwitchStmt *switchStmt );
                 virtual void visit( ChooseStmt *chooseStmt );
+                virtual void visit( CaseStmt *caseStmt );
+                virtual void visit( CatchStmt *catchStmt );
+                // virtual void visit( CaseStmt *caseStmt );
                 AutogenerateRoutines() : functionNesting( 0 ) {}
 …
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
           private:
                 virtual void visit( FunctionDecl * functionDecl );
 …
         };
+        class CompoundLiteral : public GenPoly::DeclMutator {
+                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
+                virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
+                virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
+        };
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 Pass1 pass1;
                 Pass2 pass2( doDebug, 0 );
                 Pass3 pass3( 0 );
+                CompoundLiteral compoundliteral;
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
 …
                 acceptAll( translationUnit, pass2 );
                 ReturnChecker::checkFunctionReturns( translationUnit );
+                mutateAll( translationUnit, compoundliteral );
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
 …
+        }
-        void HoistStruct::visit( IfStmt *ifStmt ) {
-                addVisit( ifStmt, *this );
+        }
-        void HoistStruct::visit( WhileStmt *whileStmt ) {
-                addVisit( whileStmt, *this );
+        }
-        void HoistStruct::visit( ForStmt *forStmt ) {
-                addVisit( forStmt, *this );
+        }
         void HoistStruct::visit( SwitchStmt *switchStmt ) {
                 addVisit( switchStmt, *this );
 …
+        }
+        void HoistStruct::visit( CaseStmt *caseStmt ) {
+                addVisit( caseStmt, *this );
+        }
+        void HoistStruct::visit( CatchStmt *cathStmt ) {
+                addVisit( cathStmt, *this );
+        }
+        // void HoistStruct::visit( CaseStmt *caseStmt ) {
+        //      addVisit( caseStmt, *this );
+        // }
         void Pass1::visit( EnumDecl *enumDecl ) {
 …
+        }
-        void AutogenerateRoutines::visit( IfStmt *ifStmt ) {
-                visitStatement( ifStmt );
+        }
-        void AutogenerateRoutines::visit( WhileStmt *whileStmt ) {
-                visitStatement( whileStmt );
+        }
-        void AutogenerateRoutines::visit( ForStmt *forStmt ) {
-                visitStatement( forStmt );
+        }
         void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
                 visitStatement( switchStmt );
 …
+        }
+        void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
+                visitStatement( caseStmt );
+        }
+        void AutogenerateRoutines::visit( CatchStmt *cathStmt ) {
+                visitStatement( cathStmt );
+        }
+        // void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
+        //      visitStatement( caseStmt );
+        // }
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
 …
+        }
+        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+                storageclass = objectDecl->get_storageClass();
+                DeclarationWithType * temp = Mutator::mutate( objectDecl );
+                storageclass = DeclarationNode::NoStorageClass;
+                return temp;
+        }
+        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+                // transform [storage_class] ... (struct S){ 3, ... };
+                // into [storage_class] struct S temp =  { 3, ... };
+                static UniqueName indexName( "_compLit" );
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
+                compLitExpr->set_type( 0 );
+                compLitExpr->set_initializer( 0 );
+                delete compLitExpr;
+                DeclarationWithType * newtempvar = mutate( tempvar );
+                addDeclaration( newtempvar );                                   // add modified temporary to current block
+                return new VariableExpr( newtempvar );
+        }
 } // namespace SymTab

src/SynTree/Expression.cc

-                      r3aba311
+                      r37218fc
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Wed Dec 09 14:10:29 2015
 // Update Count     : 34
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Apr  8 17:16:23 2016
+// Update Count     : 40
 //
 …
 #include "Type.h"
+#include "Initializer.h"
 #include "Expression.h"
 #include "Declaration.h"
 …
         os << " of ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+OffsetPackExpr::~OffsetPackExpr() { delete type; }
+void OffsetPackExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Offset pack expression on ";
         if ( type ) {
 …
+CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
+        add_result( type->clone() );
+}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
+CompoundLiteralExpr::~CompoundLiteralExpr() {
+        delete initializer;
+        delete type;
+}
+void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
+        os << "Compound Literal Expression: " << std::endl;
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
+}
 std::ostream & operator<<( std::ostream & out, Expression * expr ) {

src/SynTree/Expression.h

-                      r3aba311
+                      r37218fc
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Wed Dec 09 14:10:21 2015
 // Update Count     : 19
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Apr  8 17:18:06 2016
+// Update Count     : 21
 //
 …
 };
+/// Expression representing a pack of field-offsets for a generic type
+class OffsetPackExpr : public Expression {
+public:
+        OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 );
+        OffsetPackExpr( const OffsetPackExpr &other );
+        virtual ~OffsetPackExpr();
+        StructInstType *get_type() const { return type; }
+        void set_type( StructInstType *newValue ) { type = newValue; }
+        virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        StructInstType *type;
+};
 /// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {
 …
 };
+/// CompoundLiteralExpr represents a C99 'compound literal'
+class CompoundLiteralExpr : public Expression {
+  public:
+        CompoundLiteralExpr( Type * type, Initializer * initializer );
+        CompoundLiteralExpr( const CompoundLiteralExpr &other );
+        ~CompoundLiteralExpr();
+        Type * get_type() const { return type; }
+        void set_type( Type * t ) { type = t; }
+        Initializer * get_initializer() const { return initializer; }
+        void set_initializer( Initializer * i ) { initializer = i; }
+        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type * type;
+        Initializer * initializer;
+};
 std::ostream & operator<<( std::ostream & out, Expression * expr );

src/SynTree/Mutator.cc

-                      r3aba311
+                      r37218fc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:28:20 2016
 // Update Count     : 12
+// Last Modified On : Fri Apr  1 18:05:16 2016
+// Update Count     : 16
 //
 …
+}
+Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
+        mutateAll( offsetPackExpr->get_results(), *this );
+        offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
+        return offsetPackExpr;
+}
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         mutateAll( attrExpr->get_results(), *this );
 …
         mutateAll( valofExpr->get_results(), *this );
         return valofExpr;
+}
+Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
+        mutateAll( compLitExpr->get_results(), *this );
+        compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
+        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
+        return compLitExpr;
+}

src/SynTree/Mutator.h

-                      r3aba311
+                      r37218fc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:33:11 2016
 // Update Count     : 9
+// Last Modified On : Fri Apr  1 17:26:56 2016
+// Update Count     : 10
 //
 #include <cassert>
 …
         virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr );
         virtual Expression* mutate( OffsetofExpr *offsetofExpr );
+        virtual Expression* mutate( OffsetPackExpr *offsetPackExpr );
         virtual Expression* mutate( AttrExpr *attrExpr );
         virtual Expression* mutate( LogicalExpr *logicalExpr );
 …
         virtual Expression* mutate( AsmExpr *asmExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
+        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Type* mutate( VoidType *basicType );

src/SynTree/SynTree.h

-                      r3aba311
+                      r37218fc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:29:00 2016
 // Update Count     : 4
+// Last Modified On : Fri Apr  1 16:47:44 2016
+// Update Count     : 5
 //
 …
 class UntypedOffsetofExpr;
 class OffsetofExpr;
+class OffsetPackExpr;
 class AttrExpr;
 class LogicalExpr;
 …
 class AsmExpr;
 class UntypedValofExpr;
+class CompoundLiteralExpr;
 class Type;

src/SynTree/Visitor.cc

-                      r3aba311
+                      r37218fc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:29:23 2016
 // Update Count     : 16
+// Last Modified On : Fri Apr  1 18:05:13 2016
+// Update Count     : 18
 //
 …
+}
+void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
+        acceptAll( offsetPackExpr->get_results(), *this );
+        maybeAccept( offsetPackExpr->get_type(), *this );
+}
 void Visitor::visit( AttrExpr *attrExpr ) {
         acceptAll( attrExpr->get_results(), *this );
 …
         acceptAll( valofExpr->get_results(), *this );
         maybeAccept( valofExpr->get_body(), *this );
+}
+void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
+        acceptAll( compLitExpr->get_results(), *this );
+        maybeAccept( compLitExpr->get_type(), *this );
+        maybeAccept( compLitExpr->get_initializer(), *this );
+}

src/SynTree/Visitor.h

-                      r3aba311
+                      r37218fc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:33:35 2016
 // Update Count     : 6
+// Last Modified On : Fri Apr  1 17:26:55 2016
+// Update Count     : 7
 //
 …
         virtual void visit( UntypedOffsetofExpr *offsetofExpr );
         virtual void visit( OffsetofExpr *offsetofExpr );
+        virtual void visit( OffsetPackExpr *offsetPackExpr );
         virtual void visit( AttrExpr *attrExpr );
         virtual void visit( LogicalExpr *logicalExpr );
 …
         virtual void visit( AsmExpr *asmExpr );
         virtual void visit( UntypedValofExpr *valofExpr );
+        virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( VoidType *basicType );

src/Tuples/FlattenTuple.cc

r3aba311	r37218fc
49	49	void FlattenTuple::CollectArgs::visit( UntypedOffsetofExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
50	50	void FlattenTuple::CollectArgs::visit( OffsetofExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
	51	void FlattenTuple::CollectArgs::visit( OffsetPackExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
51	52	void FlattenTuple::CollectArgs::visit( AttrExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
52	53	void FlattenTuple::CollectArgs::visit( LogicalExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }

src/Tuples/FlattenTuple.h

r3aba311	r37218fc
45	45	virtual void visit( UntypedOffsetofExpr * );
46	46	virtual void visit( OffsetofExpr * );
	47	virtual void visit( OffsetPackExpr * );
47	48	virtual void visit( AttrExpr * );
48	49	virtual void visit( LogicalExpr * );

src/driver/cfa.cc

-                      r3aba311
+                      r37218fc
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 28 18:24:06 2016
 // Update Count     : 127
+// Last Modified On : Wed Apr  6 14:04:22 2016
+// Update Count     : 132
 //
 …
                                 nargs += 1;
                         } else if ( prefix( arg, "-std=" ) ) {
                                 std_flag = true;                                                // std=XX provided
+                                std_flag = true;                                                // -std=XX provided
                                 args[nargs] = argv[i];                                  // pass the argument along
                                 nargs += 1;
 …
                 nargs += 1;
                 if ( ! std_flag ) {                                                             // default c99, if none specified
                         args[nargs] = "-std=c99";
+                        args[nargs] = "-std=gnu99";
                         nargs += 1;
                 } // if

src/libcfa/Makefile.am

-                      r3aba311
+                      r37218fc
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Wed Mar  2 22:59:23 2016
 ## Update Count     : 119
+## Last Modified On : Wed Apr  6 21:10:44 2016
+## Update Count     : 123
 ###############################################################################
 …
         ${CC} ${CFLAGS} -c -o $@ $<
 libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 cheaders = #  expat
 cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}

src/libcfa/Makefile.in

-                      r3aba311
+                      r37218fc
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
 am__objects_1 = stdlib.$(OBJEXT) iostream.$(OBJEXT) fstream.$(OBJEXT) \
         iterator.$(OBJEXT)
+am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) iostream.$(OBJEXT) \
+        fstream.$(OBJEXT) iterator.$(OBJEXT) rational.$(OBJEXT)
 am_libcfa_a_OBJECTS = libcfa-prelude.$(OBJEXT) $(am__objects_1)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
 …
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
 libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 cheaders = #  expat
 cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 all: all-am
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iterator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa-prelude.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/limits.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stdlib.Po@am__quote@

src/libcfa/fstream

-                      r3aba311
+                      r37218fc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 15:08:14 2016
 // Update Count     : 78
+// Last Modified On : Tue Apr  5 22:37:12 2016
+// Update Count     : 82
 //
 …
 enum { separateSize = 16 };
+struct ofstream { void *file; int separate; char separator[separateSize]; };
+struct ofstream {
+        void *file;
+        _Bool sepDefault;
+        _Bool sepOnOff;
+        char separator[separateSize];
+}; // ofstream
 _Bool sepPrt( ofstream * );
 void sepOn( ofstream * );
 void sepOff( ofstream * );
+void sepReset( ofstream * );
+void sepReset( ofstream *, _Bool );
 void sepSet( ofstream *, const char * );
 const char * sepGet( ofstream * );
 void sepDisable( ofstream * );
 void sepEnable( ofstream * );
+_Bool sepDisable( ofstream * );
+_Bool sepEnable( ofstream * );
 int fail( ofstream * );
 int flush( ofstream * );
 …
 // implement context istream
+struct ifstream { void *file; };
+struct ifstream {
+        void *file;
+}; // ifstream
 int fail( ifstream * is );

src/libcfa/fstream.c

-                      r3aba311
+                      r37218fc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Feb 29 18:41:10 2016
 // Update Count     : 162
+// Last Modified On : Wed Apr  6 17:55:27 2016
+// Update Count     : 176
 //
 …
+}
 #define IO_MSG "I/O error "
+#define IO_MSG "I/O error: "
+_Bool sepPrt( ofstream * os ) { return os->separate == 1; }
+void sepOn( ofstream * os ) { if ( os->separate != 2 ) os->separate = 1; }
+void sepOff( ofstream * os ) { if ( os->separate != 2 ) os->separate = 0; }
+_Bool sepPrt( ofstream * os ) { return os->sepOnOff; }
+void sepOn( ofstream * os ) { os->sepOnOff = 1; }
+void sepOff( ofstream * os ) { os->sepOnOff = 0; }
+void sepReset( ofstream * os ) { os->sepOnOff = os->sepDefault; }
+void sepReset( ofstream * os, _Bool reset ) { os->sepDefault = reset; os->sepOnOff = os->sepDefault; }
 void sepSet( ofstream * os, const char * s ) {
         strncpy( &(os->separator[0]), s, separateSize - 1 );
 …
 } // sepSet
 const char * sepGet( ofstream * os ) { return &(os->separator[0]); }
+void sepDisable( ofstream *os ) { os->separate = 2; }
+void sepEnable( ofstream *os ) { os->separate = 0; }
+_Bool sepDisable( ofstream *os ) {
+        _Bool temp = os->sepDefault;
+        os->sepDefault = 0;
+        sepReset( os );
+        return temp;
+} // sepDisable
+_Bool sepEnable( ofstream *os ) {
+        _Bool temp = os->sepDefault;
+        os->sepDefault = 1;
+        sepReset( os );
+        return temp;
+} // sepEnable
 int fail( ofstream * os ) {
 …
         FILE *file = fopen( name, mode );
         if ( file == 0 ) {                                                                      // do not change unless successful
+                perror( IO_MSG "open output" );
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
 …
 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 0, { ' ', '\0' } };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, { ' ', '\0' } };
 ofstream *sout = &soutFile;
 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 0, { ' ', '\0' } };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, { ' ', '\0' } };
 ofstream *serr = &serrFile;
 …
         FILE *t = fopen( name, mode );
         if ( t == 0 ) {                                                                         // do not change unless successful
+                perror( IO_MSG "open input" );
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
 …
 // Local Variables: //
 // tab-width: 4 //
-// compile-command: "cfa fstream.c" //
 // End: //

src/libcfa/iostream

-                      r3aba311
+                      r37218fc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 18:05:27 2016
 // Update Count     : 85
+// Last Modified On : Tue Apr  5 22:32:37 2016
+// Update Count     : 90
 //
 …
         void sepOn( ostype * );
         void sepOff( ostype * );
+        void sepReset( ostype * );
+        void sepReset( ostype *, _Bool );
         void sepSet( ostype *, const char * );
         const char * sepGet( ostype * );
         void sepDisable( ostype * );
         void sepEnable( ostype * );
+        _Bool sepDisable( ostype * );
+        _Bool sepEnable( ostype * );
         int fail( ostype * );
         int flush( ostype * );
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * );
 forall( dtype ostype | ostream( ostype ) ) ostype * sepOff( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepDisable( ostype * );
+forall( dtype ostype | ostream( ostype ) ) ostype * sepEnable( ostype * );
 // writes the range [begin, end) to the given stream
 …
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
 struct _Istream_str1 { char * s; };
 _Istream_str1 str( char * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str1 );
+struct _Istream_cstrUC { char * s; };
+_Istream_cstrUC cstr( char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrUC );
 struct _Istream_str2 { char * s; int size; };
 _Istream_str2 str( char *, int size );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str2 );
+struct _Istream_cstrC { char * s; int size; };
+_Istream_cstrC cstr( char *, int size );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrC );
 #endif // __IOSTREAM_H__

src/libcfa/iostream.c

-                      r3aba311
+                      r37218fc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar  7 13:51:23 2016
 // Update Count     : 227
+// Last Modified On : Wed Apr  6 16:13:29 2016
+// Update Count     : 278
 //
 …
 ostype * ?|?( ostype *os, char c ) {
         prtfmt( os, "%c", c );
+        sepOff( os );
         return os;
 } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, short int si ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%hd", si );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned short int usi ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%hu", usi );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, int i ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%d", i );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned int ui ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%u", ui );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long int li ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%ld", li );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long int uli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%lu", uli );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long long int lli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%lld", lli );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long long int ulli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%llu", ulli );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, float f ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%g", f );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, double d ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%.*lg", DBL_DIG, d );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long double ld ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%.*Lg", LDBL_DIG, ld );
         return os;
 …
 ostype * ?|?( ostype *os, float _Complex fc ) {
         os | crealf( fc );
+        if ( cimagf( fc ) >= 0 ) os | '+';
+        os | "" | cimagf( fc ) | 'i';
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
+        os | cimagf( fc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 ostype * ?|?( ostype *os, double _Complex dc ) {
         os | creal( dc );
+        if ( cimag( dc ) >= 0 ) os | '+';
+        os | "" | cimag( dc ) | 'i';
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
+        os | cimag( dc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 ostype * ?|?( ostype *os, long double _Complex ldc ) {
         os | creall( ldc );
+        if ( cimagl( ldc ) >= 0 ) os | '+';
+        os | "" | cimagl( ldc ) | 'i';
+        _Bool temp = sepDisable( os );                                          // disable separators within complex value
+        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
+        os | cimagl( ldc ) | 'i';
+        sepReset( os, temp );                                                           // reset separator
         return os;
 } // ?|?
 …
 ostype * ?|?( ostype *os, const char *cp ) {
         enum { Open = 1, Close, OpenClose };
         static const char mask[256] = {
+        static const unsigned char mask[256] = {
                 // opening delimiters
                 ['('] : Open, ['['] : Open, ['{'] : Open,
                 ['$'] : Open, [L'£'] : Open, [L'¥'] : Open, [L'¢'] : Open, [L'¿'] : Open, [L'«'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
                 // closing delimiters
                 [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
                 [')'] : Close, [']'] : Close, ['}'] : Close,
                 ['%'] : Close, [L'»'] : Close,
+                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
                 // opening-closing delimiters
                 ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
+                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
         }; // mask
 …
         // null string => no separator
   if ( len == 0 ) { sepOff( os ); return os; }
+        // first character NOT spacing or closing punctuation => add left separator
+        if ( sepPrt( os ) && isspace( cp[0] ) == 0 && mask[ cp[0] ] != Close && mask[ cp[0] ] != OpenClose ) {
+        // first character IS NOT spacing or closing punctuation => add left separator
+        unsigned char ch = cp[0];                                                       // must make unsigned
+        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
                 prtfmt( os, "%s", sepGet( os ) );
         } // if
         // last character IS spacing or opening punctuation => turn off separator for next item
         unsigned int posn = len - 1;
+        if ( isspace( cp[posn] ) || mask[ cp[posn] ] == Open || mask[ cp[posn] ] == OpenClose ) {
+        ch = cp[posn];                                                                          // must make unsigned
+        if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
                 sepOff( os );
         } else {
 …
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, const void *p ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
         prtfmt( os, "%p", p );
         return os;
 …
 } // sepOff
+forall( dtype ostype | ostream( ostype ) )
+ostype * sepEnable( ostype * os ) {
+        sepEnable( os );
+        return os;
+} // sepEnable
+forall( dtype ostype | ostream( ostype ) )
+ostype * sepDisable( ostype * os ) {
+        sepDisable( os );
+        return os;
+} // sepDisable
 //---------------------------------------
 …
 } // ?|?
 _Istream_str1 str( char * s ) { _Istream_str1 s = { s }; return s; }
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, _Istream_str1 str ) {
         scanfmt( is, "%s", str.s );
         return is;
 } // str
 _Istream_str2 str( char * s, int size ) { _Istream_str2 s = { s, size }; return s; }
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, _Istream_str2 str ) {
+_Istream_cstrUC cstr( char * s ) { _Istream_cstrUC s = { s }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_cstrUC cstr ) {
+        scanfmt( is, "%s", cstr.s );
+        return is;
+} // cstr
+_Istream_cstrC cstr( char * s, int size ) { _Istream_cstrC s = { s, size }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_cstrC cstr ) {
         char buf[16];
         sprintf( buf, "%%%ds", str.size );
         scanfmt( is, buf, str.s );
         return is;
 } // str
+        sprintf( buf, "%%%ds", cstr.size );
+        scanfmt( is, buf, cstr.s );
+        return is;
+} // cstr
 // Local Variables: //

src/libcfa/limits

-                      r3aba311
+                      r37218fc
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// limits --
+//
+// Author           : Peter A. Buhr
+// Created On       : Wed Apr  6 18:06:52 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Apr  6 21:08:16 2016
+// Update Count     : 6
+//
 // Integral Constants
 const short int MIN = -32768;
 const int MIN = -2147483648;
 const long int MIN = -9223372036854775807L - 1L;
 const long long int MIN = -9223372036854775807LL - 1LL;
+extern const short int MIN;
+extern const int MIN;
+extern const long int MIN;
+extern const long long int MIN;
 const short int MAX = 32767;
 const unsigned short int MAX = 65535;
 const int MAX = 2147483647;
 const unsigned int MAX = 4294967295_U;
 const long int MAX = 9223372036854775807_L;
 const unsigned long int MAX = 4294967295_U;
 const long long int MAX = 9223372036854775807_LL;
 const unsigned long long int MAX = 18446744073709551615_ULL;
+extern const short int MAX;
+extern const unsigned short int MAX;
+extern const int MAX;
+extern const unsigned int MAX;
+extern const long int MAX;
+extern const unsigned long int MAX;
+extern const long long int MAX;
+extern const unsigned long long int MAX;
 // Floating-Point Constants
 const float PI = 3.141592_F;                            // pi
 const float PI_2 = 1.570796_F;                          // pi / 2
 const float PI_4 = 0.7853981_F;                         // pi / 4
 const float _1_PI = 0.3183098_F;                        // 1 / pi
 const float _2_PI = 0.6366197_F;                        // 2 / pi
 const float _2_SQRT_PI = 1.128379_F;                    // 2 / sqrt(pi)
+extern const float PI;                                                                  // pi
+extern const float PI_2;                                                                // pi / 2
+extern const float PI_4;                                                                // pi / 4
+extern const float _1_PI;                                                               // 1 / pi
+extern const float _2_PI;                                                               // 2 / pi
+extern const float _2_SQRT_PI;                                                  // 2 / sqrt(pi)
 const double PI = 3.14159265358979323846_D;             // pi
 const double PI_2 = 1.57079632679489661923_D;           // pi / 2
 const double PI_4 = 0.78539816339744830962_D;           // pi / 4
 const double _1_PI = 0.31830988618379067154_D;          // 1 / pi
 const double _2_PI = 0.63661977236758134308_D;          // 2 / pi
 const double _2_SQRT_PI = 1.12837916709551257390_D;     // 2 / sqrt(pi)
+extern const double PI;                                                                 // pi
+extern const double PI_2;                                                               // pi / 2
+extern const double PI_4;                                                               // pi / 4
+extern const double _1_PI;                                                              // 1 / pi
+extern const double _2_PI;                                                              // 2 / pi
+extern const double _2_SQRT_PI;                                                 // 2 / sqrt(pi)
 const long double PI = 3.1415926535897932384626433832795029_DL; // pi
 const long double PI_2 = 1.5707963267948966192313216916397514_DL; // pi / 2
 const long double PI_4 = 0.7853981633974483096156608458198757_DL; // pi / 4
 const long double _1_PI = 0.3183098861837906715377675267450287_DL; // 1 / pi
 const long double _2_PI = 0.6366197723675813430755350534900574_DL; // 2 / pi
 const long double _2_SQRT_PI = 1.1283791670955125738961589031215452_DL; // 2 / sqrt(pi)
+extern const long double PI;                                                    // pi
+extern const long double PI_2;                                                  // pi / 2
+extern const long double PI_4;                                                  // pi / 4
+extern const long double _1_PI;                                                 // 1 / pi
+extern const long double _2_PI;                                                 // 2 / pi
+extern const long double _2_SQRT_PI;                                    // 2 / sqrt(pi)
 const _Complex PI = 3.14159265358979323846_D+0.0_iD;    // pi
 const _Complex PI_2 = 1.57079632679489661923_D+0.0_iD;  // pi / 2
 const _Complex PI_4 = 0.78539816339744830962_D+0.0_iD;  // pi / 4
 const _Complex _1_PI = 0.31830988618379067154_D+0.0_iD; // 1 / pi
 const _Complex _2_PI = 0.63661977236758134308_D+0.0_iD; // 2 / pi
 const _Complex _2_SQRT_PI = 1.12837916709551257390_D+0.0_iD; // 2 / sqrt(pi)
+extern const _Complex PI;                                                               // pi
+extern const _Complex PI_2;                                                             // pi / 2
+extern const _Complex PI_4;                                                             // pi / 4
+extern const _Complex _1_PI;                                                    // 1 / pi
+extern const _Complex _2_PI;                                                    // 2 / pi
+extern const _Complex _2_SQRT_PI;                                               // 2 / sqrt(pi)
 const long _Complex PI = 3.1415926535897932384626433832795029_L+0.0iL; // pi
 const long _Complex PI_2 = 1.5707963267948966192313216916397514_L+0.0iL; // pi / 2
 const long _Complex PI_4 = 0.7853981633974483096156608458198757_L+0.0iL; // pi / 4
 const long _Complex _1_PI = 0.3183098861837906715377675267450287_L+0.0iL; // 1 / pi
 const long _Complex _2_PI = 0.6366197723675813430755350534900574_L+0.0iL; // 2 / pi
 const long _Complex _2_SQRT_PI = 1.1283791670955125738961589031215452_L+0.0iL; // 2 / sqrt(pi)
+extern const long _Complex PI;                                                  // pi
+extern const long _Complex PI_2;                                                // pi / 2
+extern const long _Complex PI_4;                                                // pi / 4
+extern const long _Complex _1_PI;                                               // 1 / pi
+extern const long _Complex _2_PI;                                               // 2 / pi
+extern const long _Complex _2_SQRT_PI;                                  // 2 / sqrt(pi)
 const float E = 2.718281;                               // e
 const float LOG2_E = 1.442695;                          // log_2(e)
 const float LOG10_E = 0.4342944;                        // log_10(e)
 const float LN_2 = 0.6931471;                           // log_e(2)
 const float LN_10 = 2.302585;                           // log_e(10)
 const float SQRT_2 = 1.414213;                          // sqrt(2)
 const float _1_SQRT_2 = 0.7071067;                      // 1 / sqrt(2)
+extern const float E;                                                                   // e
+extern const float LOG2_E;                                                              // log_2(e)
+extern const float LOG10_E;                                                             // log_10(e)
+extern const float LN_2;                                                                // log_e(2)
+extern const float LN_10;                                                               // log_e(10)
+extern const float SQRT_2;                                                              // sqrt(2)
+extern const float _1_SQRT_2;                                                   // 1 / sqrt(2)
 const double E = 2.7182818284590452354_D;               // e
 const double LOG2_E = 1.4426950408889634074_D;          // log_2(e)
 const double LOG10_E = 0.43429448190325182765_D;        // log_10(e)
 const double LN_2 = 0.69314718055994530942_D;           // log_e(2)
 const double LN_10 = 2.30258509299404568402_D;          // log_e(10)
 const double SQRT_2 = 1.41421356237309504880_D;         // sqrt(2)
 const double _1_SQRT_2 = 0.70710678118654752440_D;      // 1 / sqrt(2)
+extern const double E;                                                                  // e
+extern const double LOG2_E;                                                             // log_2(e)
+extern const double LOG10_E;                                                    // log_10(e)
+extern const double LN_2;                                                               // log_e(2)
+extern const double LN_10;                                                              // log_e(10)
+extern const double SQRT_2;                                                             // sqrt(2)
+extern const double _1_SQRT_2;                                                  // 1 / sqrt(2)
 const long double E = 2.7182818284590452353602874713526625_DL; // e
 const long double LOG2_E = 1.4426950408889634073599246810018921_DL; // log_2(e)
 const long double LOG10_E = 0.4342944819032518276511289189166051_DL; // log_10(e)
 const long double LN_2 = 0.6931471805599453094172321214581766_DL; // log_e(2)
 const long double LN_10 = 2.3025850929940456840179914546843642_DL; // log_e(10)
 const long double SQRT_2 = 1.4142135623730950488016887242096981_DL; // sqrt(2)
 const long double _1_SQRT_2 = 0.7071067811865475244008443621048490_DL; // 1/sqrt(2)
+extern const long double E;                                                             // e
+extern const long double LOG2_E;                                                // log_2(e)
+extern const long double LOG10_E;                                               // log_10(e)
+extern const long double LN_2;                                                  // log_e(2)
+extern const long double LN_10;                                                 // log_e(10)
+extern const long double SQRT_2;                                                // sqrt(2)
+extern const long double _1_SQRT_2;                                             // 1/sqrt(2)
 const _Complex E = 2.7182818284590452354_D+0.0_iD;      // e
 const _Complex LOG2_E = 1.4426950408889634074_D+0.0_iD; // log_2(e)
 const _Complex LOG10_E = 0.43429448190325182765_D+0.0_iD; // log_10(e)
 const _Complex LN_2 = 0.69314718055994530942_D+0.0_iD;  // log_e(2)
 const _Complex LN_10 = 2.30258509299404568402_D+0.0_iD; // log_e(10)
 const _Complex SQRT_2 = 1.41421356237309504880_D+0.0_iD;        // sqrt(2)
 const _Complex _1_SQRT_2 = 0.70710678118654752440_D+0.0_iD; // 1 / sqrt(2)
+extern const _Complex E;                                                                // e
+extern const _Complex LOG2_E;                                                   // log_2(e)
+extern const _Complex LOG10_E;                                                  // log_10(e)
+extern const _Complex LN_2;                                                             // log_e(2)
+extern const _Complex LN_10;                                                    // log_e(10)
+extern const _Complex SQRT_2;                                                   // sqrt(2)
+extern const _Complex _1_SQRT_2;                                                // 1 / sqrt(2)
+const long _Complex E = 2.7182818284590452353602874713526625_L+0.0_iL; // e
+const long _Complex LOG2_E = 1.4426950408889634073599246810018921_L+0.0_iL; // log_2(e)
+const long _Complex LOG10_E = 0.4342944819032518276511289189166051_L+0.0_iL; // log_10(e)
+const long _Complex LN_2 = 0.6931471805599453094172321214581766_L+0.0_iL; // log_e(2)
+const long _Complex LN_10 = 2.3025850929940456840179914546843642_L+0.0_iL; // log_e(10)
+const long _Complex SQRT_2 = 1.4142135623730950488016887242096981_L+0.0_iL; // sqrt(2)
+const long _Complex _1_SQRT_2 = 0.7071067811865475244008443621048490_L+0.0_iL; // 1 / sqrt(2)
+extern const long _Complex E;                                                   // e
+extern const long _Complex LOG2_E;                                              // log_2(e)
+extern const long _Complex LOG10_E;                                             // log_10(e)
+extern const long _Complex LN_2;                                                // log_e(2)
+extern const long _Complex LN_10;                                               // log_e(10)
+extern const long _Complex SQRT_2;                                              // sqrt(2)
+extern const long _Complex _1_SQRT_2;                                   // 1 / sqrt(2)
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //

src/libcfa/stdlib

-                      r3aba311
+                      r37218fc
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Mar 22 22:34:24 2016
 // Update Count     : 69
+// Last Modified On : Fri Apr  1 22:26:14 2016
+// Update Count     : 73
 //
 …
 extern "C" {
 #include <stddef.h>                                                                             // size_t
+#include <math.h>                                                                               // floor
 } // extern "C"
 …
 char abs( char );
 extern "C" {
 int abs( int );         // use default C routine for int
 } // extern
+int abs( int );                         // use default C routine for int
+} // extern "C"
 long int abs( long int );
 long long int abs( long long int );
 …
 double _Complex abs( double _Complex );
 long double _Complex abs( long double _Complex );
+//---------------------------------------
+float floor( float );
+extern "C" {
+double floor( double );         // use C routine for double
+} // extern "C"
+long double floor( long double );
+float ceil( float );
+extern "C" {
+double ceil( double );          // use C routine for double
+} // extern "C"
+long double ceil( long double );
 //---------------------------------------

src/libcfa/stdlib.c

-                      r3aba311
+                      r37218fc
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar 23 13:26:42 2016
 // Update Count     : 146
+// Last Modified On : Wed Mar 30 10:48:41 2016
+// Update Count     : 149
 //
 …
 //---------------------------------------
+float floor( float v ) { return floorf( v ); }
+long double floor( long double v ) { return floorl( v ); }
+float ceil( float v ) { return ceilf( v ); }
+long double ceil( long double v ) { return ceill( v ); }
+//---------------------------------------
 void rand48seed( long int s ) { srand48( s ); }
 char rand48() { return mrand48(); }

Context Navigation

Legend:

Download in other formats: