Diff [c4fd4ef79cef1612a97ce467b6d38124c5580f0e:bbdb0c643e5e1d39beac9cc933345506b44d7ff5] for / – Cforall

Jenkinsfile

-                      rc4fd4ef
+                      rbbdb0c6
+                        }
                         sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} ${targets} --quiet"
+                        sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} --quiet --prefix=${BuildDir}"
                         // Configure libcfa
 …
                 dir (BuildDir) {
                         sh "make -j 8 --no-print-directory -C libcfa/${Settings.Architecture.name}-nodebug"
+                }
+        }
+        build_stage('Build : install', true) {
+                // Build outside of the src tree to ease cleaning
+                dir (BuildDir) {
+                        sh "make -j 8 --no-print-directory install"
+                }
+        }
 …
                 echo "Archiving core dumps"
                 dir (BuildDir) {
                         archiveArtifacts artifacts: "tests/crashes/**/*", fingerprint: true
+                        archiveArtifacts artifacts: "tests/crashes/**/*,lib/**/lib*.so*", fingerprint: true
+                }
                 throw err
 …
         public String CXX
         public String CC
+        CC_Desc(String name, String CXX, String CC) {
+        public String lto
+        CC_Desc(String name, String CXX, String CC, String lto) {
                 this.name = name
                 this.CXX = CXX
+                this.CC = CC
+                this.CC  = CC
+                this.lto = lto
+        }
+}
 …
                 switch( param.Compiler ) {
                         case 'gcc-9':
                                 this.Compiler = new CC_Desc('gcc-9', 'g++-9', 'gcc-9')
+                                this.Compiler = new CC_Desc('gcc-9', 'g++-9', 'gcc-9', '-flto=auto')
                         break
                         case 'gcc-8':
                                 this.Compiler = new CC_Desc('gcc-8', 'g++-8', 'gcc-8')
+                                this.Compiler = new CC_Desc('gcc-8', 'g++-8', 'gcc-8', '-flto=auto')
                         break
                         case 'gcc-7':
                                 this.Compiler = new CC_Desc('gcc-7', 'g++-7', 'gcc-7')
+                                this.Compiler = new CC_Desc('gcc-7', 'g++-7', 'gcc-7', '-flto=auto')
                         break
                         case 'gcc-6':
                                 this.Compiler = new CC_Desc('gcc-6', 'g++-6', 'gcc-6')
+                                this.Compiler = new CC_Desc('gcc-6', 'g++-6', 'gcc-6', '-flto=auto')
                         break
                         case 'gcc-5':
                                 this.Compiler = new CC_Desc('gcc-5', 'g++-5', 'gcc-5')
+                                this.Compiler = new CC_Desc('gcc-5', 'g++-5', 'gcc-5', '-flto=auto')
                         break
                         case 'gcc-4.9':
                                 this.Compiler = new CC_Desc('gcc-4.9', 'g++-4.9', 'gcc-4.9')
+                                this.Compiler = new CC_Desc('gcc-4.9', 'g++-4.9', 'gcc-4.9', '-flto=auto')
                         break
                         case 'clang':
                                 this.Compiler = new CC_Desc('clang', 'clang++-6.0', 'gcc-6')
+                                this.Compiler = new CC_Desc('clang', 'clang++-6.0', 'gcc-6', '-flto=thin -flto-jobs=0')
                         break
                         default :
 …
         // prepare the properties
         properties ([                                                                                                   \
+                buildDiscarder(logRotator(                                                                              \
+                        artifactDaysToKeepStr: '',                                                                      \
+                        artifactNumToKeepStr: '',                                                                       \
+                        daysToKeepStr: '730',                                                                           \
+                        numToKeepStr: '1000'                                                                            \
+                )),                                                                                                             \
                 [$class: 'ParametersDefinitionProperty',                                                                \
                         parameterDefinitions: [                                                                         \

benchmark/Makefile.am

-                      rc4fd4ef
+                      rbbdb0c6
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Jan 25 09:20:44 2020
 ## Update Count     : 255
+## Last Modified On : Tue Mar 10 11:41:18 2020
+## Update Count     : 258
 ###############################################################################
 …
 creation_cfa_coroutine_DURATION = 100000000
 creation_cfa_coroutine_eager_DURATION = 10000000
+creation_cfa_generator_DURATION = 1000000000
 creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
 creation_cfa_thread_DURATION = 10000000

benchmark/Makefile.in

rc4fd4ef	rbbdb0c6
447	447	creation_cfa_coroutine_DURATION = 100000000
448	448	creation_cfa_coroutine_eager_DURATION = 10000000
	449	creation_cfa_generator_DURATION = 1000000000
449	450	creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
450	451	creation_cfa_thread_DURATION = 10000000

benchmark/creation/cfa_gen.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 #include "bench.h"
+#include "../bench.h"
 struct C {
+generator G {
         volatile int restart; // ensure compiler does not optimize away all the code
 };
 void ?{}( C & c ) { c.restart = 0; }
 void main( C & ) {}
+void ?{}( G & g ) { g.restart = 0; }
+void main( G & ) {}
 int main( int argc, char * argv[] ) {
 …
         BENCH(
                 for ( times ) {
                          C c;
+                         G g;
                 },
                 result

benchmark/ctxswitch/cfa_cor.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 #include <thread.hfa>
 #include "bench.h"
+#include "../bench.h"
 coroutine C {} c;
+coroutine C {};
 void main( __attribute__((unused)) C & ) {
         while () {
                 suspend();
+        for () {
+                suspend;
+        }
+}
 int main( int argc, char * argv[] ) {
+        C c;
         BENCH_START()
         BENCH(

benchmark/ctxswitch/cfa_gen.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 #include "../bench.h"
+typedef struct {
+        void * next;
+} C;
+void comain( C * c ) {
+        if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
+        c->next = &&s1;
+generator G {};
+void main( G & ) {
         for () {
+                return;
+          s1: ;
+                suspend;
+        }
+}
 int main( int argc, char * argv[] ) {
+        G g;
         BENCH_START()
-        C c = { 0 };
         BENCH(
                 for ( times ) {
                         comain( &c );
+                        resume( g );
                 },
                 result

configure

rc4fd4ef	rbbdb0c6
2557	2557	# don't use the default CFLAGS as they unconditonnaly add -O2
2558	2558	: ${CFLAGS=""}
	2559	: ${CXXFLAGS=""}
2559	2560
2560	2561	am__api_version='1.15'

configure.ac

rc4fd4ef	rbbdb0c6
14	14	# don't use the default CFLAGS as they unconditonnaly add -O2
15	15	: ${CFLAGS=""}
	16	: ${CXXFLAGS=""}
16	17
17	18	AM_INIT_AUTOMAKE([subdir-objects])

doc/papers/concurrency/Paper.tex

-                      rc4fd4ef
+                      rbbdb0c6
+}
 \newbox\myboxA
 \newbox\myboxB
 \newbox\myboxC
 \newbox\myboxD
+\newsavebox{\myboxA}
+\newsavebox{\myboxB}
+\newsavebox{\myboxC}
+\newsavebox{\myboxD}
 \title{\texorpdfstring{Advanced Control-flow and Concurrency in \protect\CFA}{Advanced Control-flow in Cforall}}
 …
 \lstset{language=CFA,moredelim=**[is][\color{red}]{@}{@},deletedelim=**[is][]{`}{`}}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 @coroutine@ C {} c;
 void main( C & ) { while () { @suspend;@ } }
+@coroutine@ C {};
+void main( C & ) { for () { @suspend;@ } }
 int main() { // coroutine test
+        C c;
         BENCH( for ( N ) { @resume( c );@ } )
         sout | result;
 …
 \multicolumn{1}{@{}c}{} & \multicolumn{1}{c}{Median} &\multicolumn{1}{c}{Average} & \multicolumn{1}{c@{}}{Std Dev} \\
 C function                      & 1.8           & 1.8           & 0.0   \\
 \CFA generator          & 1.8           & 1.8           & 0.1   \\
+\CFA generator          & 1.8           & 2.0           & 0.3   \\
 \CFA coroutine          & 32.5          & 32.9          & 0.8   \\
 \CFA thread                     & 93.8          & 93.6          & 2.2   \\

doc/theses/andrew_beach_MMath/Makefile

-                      rc4fd4ef
+                      rbbdb0c6
 TEXSRC=$(wildcard *.tex)
 BIBSRC=$(wildcard *.bib)
+STYSRC=$(wildcard *.sty)
+CLSSRC=$(wildcard *.cls)
 TEXLIB= .:${BUILD}:
 BIBLIB= .:../../bibliography
 …
 all: ${DOC}
 ${BUILD}/${DOC}: ${TEXSRC} ${BIBSRC} Makefile | ${BUILD}
+${BUILD}/${DOC}: ${TEXSRC} ${BIBSRC} ${STYSRC} ${CLSSRC} Makefile | ${BUILD}
         ${LATEX} ${BASE}
         ${BIBTEX} ${BUILD}/${BASE}

doc/theses/andrew_beach_MMath/thesis.tex

-                      rc4fd4ef
+                      rbbdb0c6
+% uWaterloo Thesis Template for LaTeX
+% Last Updated June 14, 2017 by Stephen Carr, IST Client Services
+% FOR ASSISTANCE, please send mail to rt-IST-CSmathsci@ist.uwaterloo.ca
+% Effective October 2006, the University of Waterloo
+% requires electronic thesis submission. See the uWaterloo thesis regulations at
+% https://uwaterloo.ca/graduate-studies/thesis.
+% DON'T FORGET TO ADD YOUR OWN NAME AND TITLE in the "hyperref" package
+% configuration. THIS INFORMATION GETS EMBEDDED IN THE FINAL PDF DOCUMENT.
+% You can view the information if you view Properties of the PDF document.
+% Many faculties/departments also require one or more printed
+% copies. This template attempts to satisfy both types of output.
+% It is based on the standard "book" document class which provides all
+% necessary sectioning structures and allows multi-part theses.
+% DISCLAIMER
+% To the best of our knowledge, this template satisfies the current uWaterloo
+% requirements. However, it is your responsibility to assure that you have met
+% all  requirements of the University and your particular department.
+% Many thanks for the feedback from many graduates that assisted the
+% development of this template.
+% -----------------------------------------------------------------------
+% By default, output is produced that is geared toward generating a PDF
+% version optimized for viewing on an electronic display, including
+% hyperlinks within the PDF.
+% E.g. to process a thesis called "mythesis.tex" based on this template, run:
+% pdflatex mythesis     -- first pass of the pdflatex processor
+% bibtex mythesis       -- generates bibliography from .bib data file(s)
+% makeindex         -- should be run only if an index is used
+% pdflatex mythesis     -- fixes numbering in cross-references,
+% pdflatex mythesis --   bibliographic references, glossaries, index, etc.
+% N.B. The "pdftex" program allows graphics in the following formats to be
+% included with the "\includegraphics" command: PNG, PDF, JPEG, TIFF
+% Tip 1: Generate your figures and photos in the size you want them to appear
+% in your thesis, rather than scaling them with \includegraphics options.
+% Tip 2: Any drawings you do should be in scalable vector graphic formats:
+% SVG, PNG, WMF, EPS and then converted to PNG or PDF, so they are scalable in
+% the final PDF as well.
+% Tip 3: Photographs should be cropped and compressed so as not to be too large.
+% To create a PDF output that is optimized for double-sided printing:
+%
+% 1) comment-out the \documentclass statement in the preamble below, and
+% un-comment the second \documentclass line.
+%
+% 2) change the value assigned below to the boolean variable
+% "PrintVersion" from "false" to "true".
+% --------------------- Start of Document Preamble -----------------------
+% Specify the document class, default style attributes, and page dimensions
+% For hyperlinked PDF, suitable for viewing on a computer, use this:
+\documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+% For PDF, suitable for double-sided printing, change the PrintVersion
+% variable below to "true" and use this \documentclass line instead of the one
+% above:
+%\documentclass[letterpaper,12pt,titlepage,openright,twoside,final]{book}
+% Some LaTeX commands I define for my own nomenclature.
+% If you have to, it's better to change nomenclature once here than in a
+% million places throughout your thesis!
+\newcommand{\package}[1]{\textbf{#1}} % package names in bold text
+\newcommand{\cmmd}[1]{\textbackslash\texttt{#1}} % command name in tt font
+\newcommand{\href}[1]{#1} % does nothing, but defines the command so the
+  % print-optimized version will ignore \href tags (redefined by hyperref pkg).
+%\newcommand{\texorpdfstring}[2]{#1} % does nothing, but defines the command
+% Anything defined here may be redefined by packages added below...
+% This package allows if-then-else control structures.
+\usepackage{ifthen}
+\newboolean{PrintVersion}
+\setboolean{PrintVersion}{false}
+% CHANGE THIS VALUE TO "true" as necessary, to improve printed results for
+% hard copies by overriding some options of the hyperref package below.
+% Main tex file for thesis document.
+\documentclass[digital]{uw-ethesis}
+\usepackage{comment}
+\usepackage{fullpage}
+\setlength{\textheight}{8.75in}
+\renewcommand\labelitemi{\footnotesize$\bullet$} % shrink bullet for level 1 itemize
+\usepackage{lmodern}                            % bold typewriter font
+\usepackage{listings}                           % format program code
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+%\DeclareTextCommandDefault{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+% parindent is relative, i.e., toggled on/off in environments like itemize, so store the value for
+% use rather than use \parident directly.
+\newlength{\parindentlnth}
+\setlength{\parindentlnth}{\parindent}
+% CFA programming language, based on ANSI C (with some gcc additions)
+\lstdefinelanguage{CFA}[ANSI]{C}{
+        morekeywords={
+                _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
+                auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
+                coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
+                __float80, float80, __float128, float128, forall, ftype, generator, _Generic, _Imaginary, __imag, __imag__,
+                inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
+                otype, restrict, resume, __restrict, __restrict__, __signed, __signed__, _Static_assert, suspend, thread,
+                _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
+                virtual, __volatile, __volatile__, waitfor, when, with, zero_t},
+        moredirectives={defined,include_next},
+        % replace/adjust listing characters that look bad in sanserif
+        literate={-}{\makebox[1ex][c]{\raisebox{0.5ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
+                {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 % {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
+                {<}{\textrm{\textless}}1 {>}{\textrm{\textgreater}}1
+                {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.5ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textrm{\textgreater}}}2,
+}
+\lstset{
+language=CFA,
+columns=fullflexible,
+basicstyle=\linespread{0.9}\tt,                 % reduce line spacing and use sanserif font
+stringstyle=\tt,                                % use typewriter font
+tabsize=5,                                      % N space tabbing
+xleftmargin=\parindentlnth,                     % indent code to paragraph indentation
+%mathescape=true,                               % LaTeX math escape in CFA code $...$
+escapechar=\$,                                  % LaTeX escape in CFA code
+keepspaces=true,
+showstringspaces=false,                         % do not show spaces with cup
+showlines=true,                                 % show blank lines at end of code
+aboveskip=4pt,                                  % spacing above/below code block
+belowskip=3pt,
+moredelim=**[is][\color{red}]{`}{`},
+}% lstset
+\lstnewenvironment{cfa}[1][]
+{\lstset{#1}}
+{}
+% inline code @...@
+% Commands used in documenting how to use the template. To remove.
+\newcommand{\package}[1]{\textbf{#1}}
+\newcommand{\cmmd}[1]{\textbackslash\texttt{#1}}
+\newcommand{\href}[1]{#1}
 % For a nomenclature (optional; available from ctan.org)
 …
 % Lots of math symbols and environments
 \usepackage{amsmath,amssymb,amstext}
 % For including graphics N.B. pdftex graphics driver
+% For including graphics, sets the pdftex graphics driver.
 \usepackage[pdftex]{graphicx}
+% I believe the general index function is covered by the glossaries.
+% \usepackage{makeidx}
+% \makeindex
+% Hyperlinks make it very easy to navigate an electronic document.
+% In addition, this is where you should specify the thesis title
+% and author as they appear in the properties of the PDF document.
+% Use the "hyperref" package
+% N.B. HYPERREF MUST BE THE LAST PACKAGE LOADED; ADD ADDITIONAL PKGS ABOVE
+% N.B. pagebackref=true provides links back from the References to the body
+% text. This can cause trouble for printing.
+\usepackage[pdftex,pagebackref=false]{hyperref} % with basic options
+\hypersetup{
+    plainpages=false,       % needed if Roman numbers in frontpages
+    unicode=false,          % non-Latin characters in Acrobat’s bookmarks
+    pdftoolbar=true,        % show Acrobat’s toolbar?
+    pdfmenubar=true,        % show Acrobat’s menu?
+    pdffitwindow=false,     % window fit to page when opened
+    pdfstartview={FitH},    % fits the width of the page to the window
+    pdftitle={uWaterloo\ LaTeX\ Thesis\ Template},    % title: CHANGE THIS TEXT!
+%    pdfauthor={Author},    % author: CHANGE THIS TEXT! and uncomment this line
+%    pdfsubject={Subject},  % subject: CHANGE THIS TEXT! and uncomment this line
+%    pdfkeywords={keyword1} {key2} {key3}, % list of keywords, and uncomment this line if desired
+    pdfnewwindow=true,      % links in new window
+    colorlinks=true,        % false: boxed links; true: colored links
+    linkcolor=blue,         % color of internal links
+    citecolor=green,        % color of links to bibliography
+    filecolor=magenta,      % color of file links
+    urlcolor=cyan           % color of external links
+}
+\ifthenelse{\boolean{PrintVersion}}{
+  % for improved print quality, override some hyperref options
+\hypersetup{
+%    colorlinks,%
+    citecolor=black,%
+    filecolor=black,%
+    linkcolor=black,%
+    urlcolor=black}
+}{} % end of ifthenelse (no else)
+\usepackage[toc,abbreviations]{glossaries-extra} % Exception to the
+% rule of hyperref being the last add-on package. If glossaries-extra is not
+% in your LaTeX distribution, get it from CTAN
+% (http://ctan.org/pkg/glossaries-extra).
+% Setting up the page margins...
+% uWaterloo thesis requirements specify a minimum of 1 inch (72pt) margin at
+% the top, bottom, and outside page edges and a 1.125 in. (81pt) gutter
+% margin (on binding side). While this is not an issue for electronic
+% viewing, a PDF may be printed, and so we have the same page layout for
+% both printed and electronic versions, we leave the gutter margin in.
+% Set margins to minimum permitted by uWaterloo thesis regulations:
+\setlength{\marginparwidth}{0pt} % width of margin notes
+% N.B. If margin notes are used, you must adjust \textwidth, \marginparwidth
+% and \marginparsep so that the space left between the margin notes and page
+% edge is less than 15 mm (0.6 in.)
+% Width of space between body text and margin notes.
+\setlength{\marginparsep}{0pt}
+\setlength{\evensidemargin}{0.125in} % Adds 1/8 in. to binding side of all
+% even-numbered pages when the "twoside" printing option is selected
+\setlength{\oddsidemargin}{0.125in} % Adds 1/8 in. to the left of all pages
+% when "oneside" printing is selected, and to the left of all odd-numbered
+% pages when "twoside" printing is selected
+% Assuming US letter paper (8.5 in. x 11 in.) and side margins as above.
+\setlength{\textwidth}{6.375in}
+\raggedbottom
+% The following statement specifies the amount of space between paragraphs.
+% Other reasonable specifications are \bigskipamount and \smallskipamount.
+\setlength{\parskip}{\medskipamount}
+% The following statement controls the line spacing.  The default
+% spacing corresponds to good typographic conventions and only slight
+% changes (e.g., perhaps "1.2"), if any, should be made.
+\renewcommand{\baselinestretch}{1} % this is the default line space setting
+% By default, each chapter will start on a recto (right-hand side)
+% page.  We also force each section of the front pages to start on
+% a recto page by inserting \cleardoublepage commands.
+% In many cases, this will require that the verso page be
+% blank and, while it should be counted, a page number should not be
+% printed.  The following statements ensure a page number is not
+% printed on an otherwise blank verso page.
+\let\origdoublepage\cleardoublepage
+\newcommand{\clearemptydoublepage}{%
+  \clearpage{\pagestyle{empty}\origdoublepage}}
+\let\cleardoublepage\clearemptydoublepage
+% Define Glossary terms (This is properly done here, in the preamble.
+% Could be \input{} from a file...)
+\usepackage{cfalab}
+\usehyperrefpackage[pdftex,pagebackref=false]{
+    pdftitle={Exception Handling in CFA},
+    pdfauthor={Andrew James Beach},
+    pdfsubject={Programming Languages},
+    pdfkeywords={exceptions,implementation},
+}
+% The \phantomsection is used to help the hyperref package create links.
+% Maybe only package that should be loaded after the hyperref package.
+% From http://ctan.org/pkg/glossaries-extra, extends glossaries which replaces
+% glossary and builds off of the makeindex system.
+\usepackage[toc,abbreviations]{glossaries-extra}
 % Main glossary entries -- definitions of relevant terminology
 \newglossaryentry{computer}
 …
 type=nomenclature,
 name=dingledorf,
+description={A person of supposed average intelligence who makes incredibly brainless misjudgments}
+description={A person of supposed average intelligence who makes incredibly
+               brainless misjudgments}
+}
 % List of Abbreviations (abbreviations are from the glossaries-extra package)
+\newabbreviation{aaaaz}{AAAAZ}{American Association of Amature Astronomers and Zoologists}
+\newabbreviation{aaaaz}{AAAAZ}{American Association of Amature Astronomers
+               and Zoologists}
 % List of Symbols
 …
 sort={label},
 type=symbols,
+description={Random vector: a location in n-dimensional Cartesian space, where each dimensional component is determined by a random process}
+}
+description={Random vector: a location in n-dimensional Cartesian space, where
+               each dimensional component is determined by a random process}
+}
+% Must be here of cause problems with glossaries-extra.
+\lstMakeShortInline$%
+% Generate the glossaries defined above.
 \makeglossaries
-%======================================================================
-%   L O G I C A L    D O C U M E N T -- the content of your thesis
-%======================================================================
 \begin{document}
-% For a large document, it is a good idea to divide your thesis
-% into several files, each one containing one chapter.
-% To illustrate this idea, the "front pages" (i.e., title page,
-% declaration, borrowers' page, abstract, acknowledgements,
-% dedication, table of contents, list of tables, list of figures,
-% nomenclature) are contained within the file "uw-ethesis-frontpgs.tex" which
-% is included into the document by the following statement.
 %----------------------------------------------------------------------
 % FRONT MATERIAL
 …
 % MAIN BODY
 %----------------------------------------------------------------------
+% Because this is a short document, and to reduce the number of files
+% needed for this template, the chapters are not separate
+% documents as suggested above, but you get the idea. If they were
+% separate documents, they would each start with the \chapter command, i.e, do
+% not contain \documentclass or \begin{document} and \end{document} commands.
+\input{unwinding}
 %======================================================================
 \chapter{Introduction}
 …
 %----------------------------------------------------------------------
+% B I B L I O G R A P H Y
+% -----------------------
+% The following statement selects the style to use for references. It controls
+% the sort order of the entries in the bibliography and also the formatting
+% for the in-text labels.
+\bibliographystyle{plain}
+% This specifies the location of the file containing the bibliographic
+% information. It assumes you're using BibTeX (if not, why not?).
+% This is needed if the book class is used, to place the anchor in the correct
+% page, because the bibliography will start on its own page.
+%----------------------------------------------------------------------
+% BIBLIOGRAPHY
+%----------------------------------------------------------------------
 % Use \clearpage instead if the document class uses the "oneside" argument.
 \cleardoublepage
-% With hyperref package, enables hyperlinking from the table of contents to
-% bibliography
 \phantomsection
+% The following statement causes the title "References" to be used for the
+% bibliography section:
+\renewcommand*{\bibname}{References}
+% Add the References to the Table of Contents
+\addcontentsline{toc}{chapter}{\textbf{References}}
+% Tip 5: You can create multiple .bib files to organize your references. Just
+% list them all in the \bibliogaphy command, separated by commas (no spaces).
+% Bibliography setup and creation, renamed to References.
+\addcontentsline{toc}{chapter}{\textbf{\bibname}}
+\bibliographystyle{plain}
 \bibliography{thesis}
+% The following statement causes the specified references to be added to the
+% bibliography even if they were not cited in the text. The asterisk is a
+% wildcard that causes all entries in the bibliographic database to be
+% included (optional).
+% Include all uncited entries in the bibliography.
 \nocite{*}
 % The \appendix statement indicates the beginning of the appendices.
+% Begin the appendix, add a title and table of contents entry.
 \appendix
-% Add a title page before the appendices and a line in the Table of Contents
 \chapter*{APPENDICES}
 \addcontentsline{toc}{chapter}{APPENDICES}

doc/theses/thierry_delisle_PhD/comp_II/comp_II.tex

-                      rc4fd4ef
+                      rbbdb0c6
 \usepackage{graphicx}
 \usepackage{epic,eepic}
-\usepackage[hidelinks]{hyperref}
 \usepackage{glossaries}
 \usepackage{textcomp}
+\usepackage[hidelinks]{hyperref}
 %\usepackage[margin=1in]{geometry}
 %\usepackage{float}
 …
 \begin{table}
         \begin{center}
                 \begin{tabular}{|c|c|c|}
                         \hline
                         & Many Processors & Few Processors \\
+                \begin{tabular}{|r|l|l|}
+                        \cline{2-3}
+                        \multicolumn{1}{r|}{} & \multicolumn{1}{c|}{Many Processors} & \multicolumn{1}{c|}{Few Processors} \\
                         \hline
                         Many Threads & A: good performance & B: good performance \\
 …
-\cleardoublepage
 % B I B L I O G R A P H Y
 % -----------------------------
+\addcontentsline{toc}{chapter}{Bibliography}
+\cleardoublepage
+\phantomsection         % allows hyperref to link to the correct page
+\addcontentsline{toc}{section}{\refname}
 \bibliographystyle{plain}
 \bibliography{pl,local}
+% G L O S S A R Y
+% -----------------------------
 \cleardoublepage
 \phantomsection         % allows hyperref to link to the correct page
+% G L O S S A R Y
+% -----------------------------
+\addcontentsline{toc}{chapter}{Glossary}
+\addcontentsline{toc}{section}{Glossary}
 \printglossary
-\cleardoublepage
-\phantomsection         % allows hyperref to link to the correct page
 \end{document}

libcfa/prelude/builtins.c

-                      rc4fd4ef
+                      rbbdb0c6
 void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+forall(dtype T)
+static inline T & identity(T & i) {
+        return i;
+}
+// generator support
+struct $generator {
+        inline int;
+};
+static inline void  ?{}($generator & this) { ((int&)this) = 0; }
+static inline void ^?{}($generator &) {}
+trait is_generator(dtype T) {
+      void main(T & this);
+      $generator * get_generator(T & this);
+};
+forall(dtype T | is_generator(T))
+static inline T & resume(T & gen) {
+        main(gen);
+        return gen;
+}
 // implicit increment, decrement if += defined, and implicit not if != defined

libcfa/src/Makefile.am

-                      rc4fd4ef
+                      rbbdb0c6
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Mon Jul 15 22:43:27 2019
 ## Update Count     : 241
+## Last Modified On : Mon Mar 16 18:07:59 2020
+## Update Count     : 242
 ###############################################################################
 …
 #----------------------------------------------------------------------------------------------------------------
 if BUILDLIB
 headers_nosrc = math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
+headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
 headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
           containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa

libcfa/src/Makefile.in

-                      rc4fd4ef
+                      rbbdb0c6
         limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
         containers/maybe.hfa containers/pair.hfa containers/result.hfa \
         containers/vector.hfa math.hfa gmp.hfa time_t.hfa \
+        containers/vector.hfa bitmanip.hfa math.hfa gmp.hfa time_t.hfa \
         bits/align.hfa bits/containers.hfa bits/defs.hfa \
         bits/debug.hfa bits/locks.hfa concurrency/coroutine.hfa \
 …
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 =
+AM_V_PY = $(am__v_PY_@AM_V@)
+am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
+am__v_PY_0 = @echo "  PYTHON  " $@;
+am__v_PY_1 =
 AM_V_RUST = $(am__v_RUST_@AM_V@)
 am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
 am__v_RUST_0 = @echo "  RUST     " $@;
+am__v_RUST_0 = @echo "  RUST    " $@;
 am__v_RUST_1 =
 AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
 am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
 am__v_NODEJS_0 = @echo "  NODEJS     " $@;
+am__v_NODEJS_0 = @echo "  NODEJS  " $@;
 am__v_NODEJS_1 =
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
 …
 #----------------------------------------------------------------------------------------------------------------
 @BUILDLIB_TRUE@headers_nosrc = math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
+@BUILDLIB_TRUE@headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
 @BUILDLIB_FALSE@headers =
 @BUILDLIB_TRUE@headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \

libcfa/src/concurrency/coroutine.cfa

rc4fd4ef	rbbdb0c6
208	208
209	209	if(cor->state == Primed) {
210		suspend();
	210	__cfactx_suspend();
211	211	}
212	212

libcfa/src/concurrency/coroutine.hfa

-                      rc4fd4ef
+                      rbbdb0c6
 //-----------------------------------------------------------------------------
 // Public coroutine API
-static inline void suspend(void);
-forall(dtype T | is_coroutine(T))
-static inline T & resume(T & cor);
 forall(dtype T | is_coroutine(T))
 void prime(T & cor);
 …
 // Suspend implementation inlined for performance
+static inline void suspend(void) {
+        // optimization : read TLS once and reuse it
+        // Safety note: this is preemption safe since if
+        // preemption occurs after this line, the pointer
+        // will also migrate which means this value will
+        // stay in syn with the TLS
+        $coroutine * src = TL_GET( this_thread )->curr_cor;
+extern "C" {
+        static inline void __cfactx_suspend(void) {
+                // optimization : read TLS once and reuse it
+                // Safety note: this is preemption safe since if
+                // preemption occurs after this line, the pointer
+                // will also migrate which means this value will
+                // stay in syn with the TLS
+                $coroutine * src = TL_GET( this_thread )->curr_cor;
         assertf( src->last != 0,
                 "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
                 "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
                 src->name, src );
         assertf( src->last->state != Halted,
                 "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
                 "Possible cause is terminated coroutine's main routine has already returned.",
                 src->name, src, src->last->name, src->last );
+                assertf( src->last != 0,
+                        "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
+                        "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
+                        src->name, src );
+                assertf( src->last->state != Halted,
+                        "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
+                        "Possible cause is terminated coroutine's main routine has already returned.",
+                        src->name, src, src->last->name, src->last );
+        $ctx_switch( src, src->last );
+                $ctx_switch( src, src->last );
+        }
+}

libcfa/src/exception.c

-                      rc4fd4ef
+                      rbbdb0c6
+}
-#pragma GCC push_options
-#pragma GCC optimize("O0")
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
 …
         return _URC_CONTINUE_UNWIND;
+}
+#pragma GCC push_options
+#pragma GCC optimize("O0")
 // Try statements are hoisted out see comments for details. While this could probably be unique

libcfa/src/interpose.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar  2 17:37:00 2020
 // Update Count     : 176
+// Last Modified On : Fri Mar 13 17:35:37 2020
+// Update Count     : 178
 //
 …
         if ( fmt[strlen( fmt ) - 1] != '\n' ) {                         // add optional newline if missing at the end of the format text
                 __cfaabi_dbg_write( "\n", 1 );
+                __cfaabi_bits_write( STDERR_FILENO, "\n", 1 );
         } // if
         kernel_abort_msg( kernel_data, abort_text, abort_text_size );

libcfa/src/iostream.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar  5 15:56:16 2020
 // Update Count     : 834
+// Last Modified On : Wed Mar 11 14:35:35 2020
+// Update Count     : 860
 //
 …
 #define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
 forall( dtype ostype | ostream( ostype ) ) \
+static void base10_128( ostype & os, _Ostream_Manip(T) fmt ) { \
+        if ( fmt.val > UINT64_MAX ) { \
+                base10_128( os, fmt.val / P10_UINT64 ); /* recursive */ \
+                _Ostream_Manip(unsigned long long int) fmt2 @= { (uint64_t)(fmt.val % P10_UINT64), 0, 19, 'u', { .all : 0 } }; \
+                fmt2.flags.nobsdp = true; \
+                printf( "fmt2 %c %lld %d\n", fmt2.base, fmt2.val, fmt2.all );   \
+static void base10_128( ostype & os, _Ostream_Manip(T) f ) { \
+        if ( f.val > UINT64_MAX ) { \
+                unsigned long long int lsig = f.val % P10_UINT64; \
+                f.val /= P10_UINT64; /* msig */ \
+                base10_128( os, f ); /* recursion */ \
+                _Ostream_Manip(unsigned long long int) fmt @= { lsig, 0, 19, 'u', { .all : 0 } }; \
+                fmt.flags.nobsdp = true; \
+                /* printf( "fmt1 %c %lld %d\n", fmt.base, fmt.val, fmt.all ); */ \
                 sepOff( os ); \
                 (ostype &)(os | fmt2); \
+                (ostype &)(os | fmt); \
         } else { \
                 printf( "fmt %c %lld %d\n", fmt.base, (unsigned long long int)fmt.val, fmt.all ); \
                 _Ostream_Manip(SIGNED long long int) x @= { (unsigned long long int)fmt.val, fmt.wd, fmt.pc, fmt.base, { .all : fmt.all } }; \
                 (ostype &)(os | x); \
+                /* printf( "fmt2 %c %lld %d\n", f.base, (unsigned long long int)f.val, f.all ); */ \
+                _Ostream_Manip(SIGNED long long int) fmt @= { (SIGNED long long int)f.val, f.wd, f.pc, f.base, { .all : f.all } }; \
+                (ostype &)(os | fmt); \
         } /* if */ \
 } /* base10_128 */                                                 \
+} /* base10_128 */ \
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
 …
                                 if ( f.base == 'b' | f.base == 'B' ) { \
                                         if ( f.wd > 64 ) fmt.wd = f.wd - 64; \
+                                        if ( f.flags.pc && f.pc > 64 ) fmt.pc = f.pc - 64; \
                                         fmt2.wd = 64; \
                                         (ostype &)(os | fmt | "" | fmt2); \
 …
                                         fmt.val = (unsigned long long int)fmt.val >> 2; \
                                         if ( f.wd > 21 ) fmt.wd = f.wd - 21; \
+                                        if ( f.flags.pc && f.pc > 21 ) fmt.pc = f.pc - 21; \
                                         fmt2.wd = 1; \
                                         fmt2.val = ((msig & 0x3) << 1) + 1; \
 …
                                 } else { \
                                         if ( f.flags.left ) { \
                                                 if ( f.wd > 16 ) fmt2.wd = f.wd - 16;   \
                                                 fmt.wd = 16;                                                    \
+                                                if ( f.wd > 16 ) fmt2.wd = f.wd - 16; \
+                                                fmt.wd = 16; \
                                         } else { \
+                                                if ( f.wd > 16 ) fmt.wd = f.wd - 16;    \
+                                                fmt2.wd = 16;                                                   \
+                                                if ( f.wd > 16 ) fmt.wd = f.wd - 16; \
+                                                if ( f.flags.pc && f.pc > 16 ) fmt.pc = f.pc - 16; \
+                                                fmt2.wd = 16; \
                                         } /* if */ \
                                         (ostype &)(os | fmt | "" | fmt2); \
 …
                         } /* if */ \
                 } else { \
+                        if ( CODE == 'd' ) { \
+                                if ( f.val < 0 )  { fmt( os, "-" ); sepOff( os ); f.val = -f.val; f.flags.sign = false; } \
+                        } /* if */ \
                         base10_128( os, f ); \
                 } /* if */ \

src/AST/Convert.cpp

-                      rc4fd4ef
+                      rbbdb0c6
+        }
+        const ast::Stmt * visit(const ast::SuspendStmt * node ) override final {
+                if ( inCache( node ) ) return nullptr;
+                auto stmt = new SuspendStmt();
+                stmt->then   = get<CompoundStmt>().accept1( node->then   );
+                switch(node->type) {
+                        case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
+                        case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
+                        case ast::SuspendStmt::Generator: stmt->type = SuspendStmt::Generator; break;
+                }
+                return stmtPostamble( stmt, node );
+        }
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
                 if ( inCache( node ) ) return nullptr;
 …
+        }
+        virtual void visit( const SuspendStmt * old ) override final {
+                if ( inCache( old ) ) return;
+                ast::SuspendStmt::Type type;
+                switch (old->type) {
+                        case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
+                        case SuspendStmt::Generator: type = ast::SuspendStmt::Generator; break;
+                        case SuspendStmt::None     : type = ast::SuspendStmt::None     ; break;
+                        default: abort();
+                }
+                this->node = new ast::SuspendStmt(
+                        old->location,
+                        GET_ACCEPT_1(then  , CompoundStmt),
+                        type,
+                        GET_LABELS_V(old->labels)
+                );
+                cache.emplace( old, this->node );
+        }
         virtual void visit( const WaitForStmt * old ) override final {
                 if ( inCache( old ) ) return;

src/AST/Decl.hpp

-                      rc4fd4ef
+                      rbbdb0c6
         bool is_coroutine() { return kind == Coroutine; }
+        bool is_monitor() { return kind == Monitor; }
+        bool is_thread() { return kind == Thread; }
+        bool is_generator() { return kind == Generator; }
+        bool is_monitor  () { return kind == Monitor  ; }
+        bool is_thread   () { return kind == Thread   ; }
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Fwd.hpp

rc4fd4ef	rbbdb0c6
53	53	class CatchStmt;
54	54	class FinallyStmt;
	55	class SuspendStmt;
55	56	class WaitForStmt;
56	57	class WithStmt;

src/AST/Pass.hpp

rc4fd4ef	rbbdb0c6
111	111	const ast::Stmt * visit( const ast::CatchStmt * ) override final;
112	112	const ast::Stmt * visit( const ast::FinallyStmt * ) override final;
	113	const ast::Stmt * visit( const ast::SuspendStmt * ) override final;
113	114	const ast::Stmt * visit( const ast::WaitForStmt * ) override final;
114	115	const ast::Decl * visit( const ast::WithStmt * ) override final;

src/AST/Pass.impl.hpp

-                      rc4fd4ef
+                      rbbdb0c6
 //--------------------------------------------------------------------------
+// FinallyStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SuspendStmt * node ) {
+        VISIT_START( node );
+        VISIT(
+                maybe_accept( node, &SuspendStmt::then   );
+        )
+        VISIT_END( Stmt, node );
+}
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename pass_t >

src/AST/Print.cpp

-                      rc4fd4ef
+                      rbbdb0c6
                 safe_print( node->body );
                 --indent;
+                return node;
+        }
+        virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
+                os << "Suspend Statement";
+                switch (node->type) {
+                        case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                        case ast::SuspendStmt::Generator: os << " for generator"; break;
+                        case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                }
+                os << endl;
+                ++indent;
+                if(node->then) {
+                        os << indent << " with post statement :" << endl;
+                        safe_print( node->then );
+                }
+                ++indent;
                 return node;

src/AST/Stmt.hpp

-                      rc4fd4ef
+                      rbbdb0c6
 };
+/// Suspend statement
+class SuspendStmt final : public Stmt {
+public:
+        ptr<CompoundStmt> then;
+        enum Type { None, Coroutine, Generator } type = None;
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
+        : Stmt(loc, std::move(labels)), then(then), type(type) {}
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
+        MUTATE_FRIEND
+};
 /// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
 class WaitForStmt final : public Stmt {

src/AST/Visitor.hpp

rc4fd4ef	rbbdb0c6
47	47	virtual const ast::Stmt * visit( const ast::CatchStmt * ) = 0;
48	48	virtual const ast::Stmt * visit( const ast::FinallyStmt * ) = 0;
	49	virtual const ast::Stmt * visit( const ast::SuspendStmt * ) = 0;
49	50	virtual const ast::Stmt * visit( const ast::WaitForStmt * ) = 0;
50	51	virtual const ast::Decl * visit( const ast::WithStmt * ) = 0;

src/Common/PassVisitor.h

-                      rc4fd4ef
+                      rbbdb0c6
         virtual void visit( FinallyStmt * finallyStmt ) override final;
         virtual void visit( const FinallyStmt * finallyStmt ) override final;
+        virtual void visit( SuspendStmt * suspendStmt ) override final;
+        virtual void visit( const SuspendStmt * suspendStmt ) override final;
         virtual void visit( WaitForStmt * waitforStmt ) override final;
         virtual void visit( const WaitForStmt * waitforStmt ) override final;
 …
         virtual Statement * mutate( CatchStmt * catchStmt ) override final;
         virtual Statement * mutate( FinallyStmt * finallyStmt ) override final;
+        virtual Statement * mutate( SuspendStmt * suspendStmt ) override final;
         virtual Statement * mutate( WaitForStmt * waitforStmt ) override final;
         virtual Declaration * mutate( WithStmt * withStmt ) override final;

src/Common/PassVisitor.impl.h

-                      rc4fd4ef
+                      rbbdb0c6
 //--------------------------------------------------------------------------
+// SuspendStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( SuspendStmt * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->then  , *this );
+        VISIT_END( node );
+}
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const SuspendStmt * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->then  , *this );
+        VISIT_END( node );
+}
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( SuspendStmt * node ) {
+        MUTATE_START( node );
+        maybeMutate_impl( node->then  , *this );
+        MUTATE_END( Statement, node );
+}
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename pass_type >

src/Concurrency/Keywords.cc

-                      rc4fd4ef
+                      rbbdb0c6
 #include "Concurrency/Keywords.h"
+#include <cassert>                 // for assert
+#include <string>                  // for string, operator==
+#include "Common/PassVisitor.h"    // for PassVisitor
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for deleteAll, map_range
+#include "CodeGen/OperatorTable.h" // for isConstructor
+#include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "SynTree/LinkageSpec.h"   // for Cforall
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
+#include "SynTree/Expression.h"    // for VariableExpr, ConstantExpr, Untype...
+#include "SynTree/Initializer.h"   // for SingleInit, ListInit, Initializer ...
+#include "SynTree/Label.h"         // for Label
+#include "SynTree/Statement.h"     // for CompoundStmt, DeclStmt, ExprStmt
+#include "SynTree/Type.h"          // for StructInstType, Type, PointerType
+#include "SynTree/Visitor.h"       // for Visitor, acceptAll
+#include <cassert>                        // for assert
+#include <string>                         // for string, operator==
+#include "Common/PassVisitor.h"           // for PassVisitor
+#include "Common/SemanticError.h"         // for SemanticError
+#include "Common/utility.h"               // for deleteAll, map_range
+#include "CodeGen/OperatorTable.h"        // for isConstructor
+#include "ControlStruct/LabelGenerator.h" // for LebelGenerator
+#include "InitTweak/InitTweak.h"          // for getPointerBase
+#include "SynTree/LinkageSpec.h"          // for Cforall
+#include "SynTree/Constant.h"             // for Constant
+#include "SynTree/Declaration.h"          // for StructDecl, FunctionDecl, ObjectDecl
+#include "SynTree/Expression.h"           // for VariableExpr, ConstantExpr, Untype...
+#include "SynTree/Initializer.h"          // for SingleInit, ListInit, Initializer ...
+#include "SynTree/Label.h"                // for Label
+#include "SynTree/Statement.h"            // for CompoundStmt, DeclStmt, ExprStmt
+#include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
+#include "SynTree/Visitor.h"              // for Visitor, acceptAll
 class Attribute;
 …
         };
         //-----------------------------------------------------------------------------
         //Handles monitor type declarations :
 …
         //-----------------------------------------------------------------------------
+        //Handles generator type declarations :
+        // generator MyGenerator {                   struct MyGenerator {
+        //      int data;                                  int data;
+        //      a_struct_t more_data;                      a_struct_t more_data;
+        //                                =>             int __gen_next;
+        // };                                        };
+        //
+        class GeneratorKeyword final : public ConcurrentSueKeyword {
+          public:
+                GeneratorKeyword() : ConcurrentSueKeyword(
+                        "$generator",
+                        "__generator_state",
+                        "get_generator",
+                        "Unable to find builtin type $generator\n",
+                        true,
+                        AggregateDecl::Generator
+                )
+                {}
+                virtual ~GeneratorKeyword() {}
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_generator(); }
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< GeneratorKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+        };
+        //-----------------------------------------------------------------------------
+        class SuspendKeyword final : public WithStmtsToAdd, public WithGuards {
+        public:
+                SuspendKeyword() = default;
+                virtual ~SuspendKeyword() = default;
+                void  premutate( FunctionDecl * );
+                DeclarationWithType * postmutate( FunctionDecl * );
+                Statement * postmutate( SuspendStmt * );
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< SuspendKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+        private:
+                DeclarationWithType * is_main( FunctionDecl * );
+                bool is_real_suspend( FunctionDecl * );
+                Statement * make_generator_suspend( SuspendStmt * );
+                Statement * make_coroutine_suspend( SuspendStmt * );
+                struct LabelPair {
+                        Label obj;
+                        int   idx;
+                };
+                LabelPair make_label() {
+                        labels.push_back( gen.newLabel("generator") );
+                        return { labels.back(), int(labels.size()) };
+                }
+                DeclarationWithType * in_generator = nullptr;
+                FunctionDecl * decl_suspend = nullptr;
+                std::vector<Label> labels;
+                ControlStruct::LabelGenerator & gen = *ControlStruct::LabelGenerator::getGenerator();
+        };
+        //-----------------------------------------------------------------------------
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
 …
                 CoroutineKeyword        ::implement( translationUnit );
                 MonitorKeyword  ::implement( translationUnit );
+                GeneratorKeyword  ::implement( translationUnit );
+                SuspendKeyword    ::implement( translationUnit );
+        }
 …
                 declsToAddAfter.push_back( get_decl );
+                // get_decl->fixUniqueId();
+        }
+        }
+        //=============================================================================================
+        // Suspend keyword implementation
+        //=============================================================================================
+        DeclarationWithType * SuspendKeyword::is_main( FunctionDecl * func) {
+                if(func->name != "main") return nullptr;
+                if(func->type->parameters.size() != 1) return nullptr;
+                auto param = func->type->parameters.front();
+                auto type  = dynamic_cast<ReferenceType * >(param->get_type());
+                if(!type) return nullptr;
+                auto obj   = dynamic_cast<StructInstType *>(type->base);
+                if(!obj) return nullptr;
+                if(!obj->baseStruct->is_generator()) return nullptr;
+                return param;
+        }
+        bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
+                if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
+                if(func->name != "__cfactx_suspend") return false; // the real suspend has a specific name
+                if(func->type->parameters.size() != 0) return false; // Too many parameters
+                if(func->type->returnVals.size() != 0) return false; // Too many return values
+                return true;
+        }
+        void SuspendKeyword::premutate( FunctionDecl * func ) {
+                GuardValue(in_generator);
+                in_generator = nullptr;
+                // Is this the real suspend?
+                if(is_real_suspend(func)) {
+                        decl_suspend = decl_suspend ? decl_suspend : func;
+                        return;
+                }
+                // Is this the main of a generator?
+                auto param = is_main( func );
+                if(!param) return;
+                if(func->type->returnVals.size() != 0) SemanticError(func->location, "Generator main must return void");
+                in_generator = param;
+                GuardValue(labels);
+                labels.clear();
+        }
+        DeclarationWithType * SuspendKeyword::postmutate( FunctionDecl * func ) {
+                if( !func->statements ) return func; // Not the actual definition, don't do anything
+                if( !in_generator     ) return func; // Not in a generator, don't do anything
+                if( labels.empty()    ) return func; // Generator has no states, nothing to do, could throw a warning
+                // This is a generator main, we need to add the following code to the top
+                // static void * __generator_labels[] = {&&s0, &&s1, ...};
+                // goto * __generator_labels[gen.__generator_state];
+                const auto & loc = func->location;
+                const auto first_label = gen.newLabel("generator");
+                // for each label add to declaration
+                std::list<Initializer*> inits = { new SingleInit( new LabelAddressExpr( first_label ) ) };
+                for(const auto & label : labels) {
+                        inits.push_back(
+                                new SingleInit(
+                                        new LabelAddressExpr( label )
+                                )
+                        );
+                }
+                auto init = new ListInit(std::move(inits), noDesignators, true);
+                labels.clear();
+                // create decl
+                auto decl = new ObjectDecl(
+                        "__generator_labels",
+                        Type::StorageClasses( Type::Static ),
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new ArrayType(
+                                Type::Qualifiers(),
+                                new PointerType(
+                                        Type::Qualifiers(),
+                                        new VoidType( Type::Qualifiers() )
+                                ),
+                                nullptr,
+                                false, false
+                        ),
+                        init
+                );
+                // create the goto
+                assert(in_generator);
+                auto go_decl = new ObjectDecl(
+                        "__generator_label",
+                        noStorageClasses,
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new PointerType(
+                                Type::Qualifiers(),
+                                new VoidType( Type::Qualifiers() )
+                        ),
+                        new SingleInit(
+                                new UntypedExpr(
+                                        new NameExpr("?[?]"),
+                                        {
+                                                new NameExpr("__generator_labels"),
+                                                new UntypedMemberExpr(
+                                                        new NameExpr("__generator_state"),
+                                                        new VariableExpr( in_generator )
+                                                )
+                                        }
+                                )
+                        )
+                );
+                go_decl->location = loc;
+                auto go = new BranchStmt(
+                        new VariableExpr( go_decl ),
+                        BranchStmt::Goto
+                );
+                go->location = loc;
+                go->computedTarget->location = loc;
+                auto noop = new NullStmt({ first_label });
+                noop->location = loc;
+                // wrap everything in a nice compound
+                auto body = new CompoundStmt({
+                        new DeclStmt( decl ),
+                        new DeclStmt( go_decl ),
+                        go,
+                        noop,
+                        func->statements
+                });
+                body->location   = loc;
+                func->statements = body;
+                return func;
+        }
+        Statement * SuspendKeyword::postmutate( SuspendStmt * stmt ) {
+                SuspendStmt::Type type = stmt->type;
+                if(type == SuspendStmt::None) {
+                        // This suspend has a implicit target, find it
+                        type = in_generator ? SuspendStmt::Generator : SuspendStmt::Coroutine;
+                }
+                // Check that the target makes sense
+                if(!in_generator && type == SuspendStmt::Generator) SemanticError( stmt->location, "'suspend generator' must be used inside main of generator type.");
+                // Act appropriately
+                switch(type) {
+                        case SuspendStmt::Generator: return make_generator_suspend(stmt);
+                        case SuspendStmt::Coroutine: return make_coroutine_suspend(stmt);
+                        default: abort();
+                }
+        }
+        Statement * SuspendKeyword::make_generator_suspend( SuspendStmt * stmt ) {
+                assert(in_generator);
+                // Target code is :
+                //   gen.__generator_state = X;
+                //   { THEN }
+                //   return;
+                //   __gen_X:;
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+                // Build the label and get its index
+                auto label = make_label();
+                // Create the context saving statement
+                auto save = new ExprStmt( new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new UntypedMemberExpr(
+                                        new NameExpr("__generator_state"),
+                                        new VariableExpr( in_generator )
+                                ),
+                                new ConstantExpr(
+                                        Constant::from_int( label.idx )
+                                )
+                        }
+                ));
+                assert(save->expr);
+                save->location = loc;
+                stmtsToAddBefore.push_back( save );
+                // if we have a then add it here
+                auto then = stmt->then;
+                stmt->then = nullptr;
+                delete stmt;
+                if(then) stmtsToAddBefore.push_back( then );
+                // Create the return statement
+                auto ret = new ReturnStmt( nullptr );
+                ret->location = loc;
+                stmtsToAddBefore.push_back( ret );
+                // Create the null statement with the created label
+                auto noop = new NullStmt({ label.obj });
+                noop->location = loc;
+                // Return the null statement to take the place of the previous statement
+                return noop;
+        }
+        Statement * SuspendKeyword::make_coroutine_suspend( SuspendStmt * stmt ) {
+                if(stmt->then) SemanticError( stmt->location, "Compound statement following coroutines is not implemented.");
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+                delete stmt;
+                // Create the call expression
+                if(!decl_suspend) SemanticError( loc, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>\n");
+                auto expr = new UntypedExpr( VariableExpr::functionPointer( decl_suspend ) );
+                expr->location = loc;
+                // Change this statement into a regular expr
+                assert(expr);
+                auto nstmt = new ExprStmt( expr );
+                nstmt->location = loc;
+                return nstmt;
+        }
         //=============================================================================================

src/Parser/ParseNode.h

rc4fd4ef	rbbdb0c6
428	428	Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
429	429	Statement * build_directive( std::string * directive );
	430	SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
430	431	WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
431	432	WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );

src/Parser/StatementNode.cc

-                      rc4fd4ef
+                      rbbdb0c6
 } // build_finally
+SuspendStmt * build_suspend( StatementNode * then, SuspendStmt::Type type ) {
+        auto node = new SuspendStmt();
+        node->type = type;
+        std::list< Statement * > stmts;
+        buildMoveList< Statement, StatementNode >( then, stmts );
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                node->then = dynamic_cast< CompoundStmt * >( stmts.front() );
+        }
+        return node;
+}
 WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
         auto node = new WaitForStmt();

src/Parser/TypeData.cc

rc4fd4ef	rbbdb0c6
769	769	case AggregateDecl::Struct:
770	770	case AggregateDecl::Coroutine:
	771	case AggregateDecl::Generator:
771	772	case AggregateDecl::Monitor:
772	773	case AggregateDecl::Thread:

src/Parser/lex.ll

-                      rc4fd4ef
+                      rbbdb0c6
 #define FLOATXX(v) KEYWORD_RETURN(v);
 #else
 #define FLOATXX(v) IDENTIFIER_RETURN();
+#define FLOATXX(v) IDENTIFIER_RETURN();
 #endif // HAVE_KEYWORDS_FLOATXX
 …
 _Static_assert  { KEYWORD_RETURN(STATICASSERT); }               // C11
 struct                  { KEYWORD_RETURN(STRUCT); }
+        /* suspend                      { KEYWORD_RETURN(SUSPEND); }                    // CFA */
+suspend                 { KEYWORD_RETURN(SUSPEND); }                    // CFA
 switch                  { KEYWORD_RETURN(SWITCH); }
 thread                  { KEYWORD_RETURN(THREAD); }                             // C11

src/Parser/parser.yy

-                      rc4fd4ef
+                      rbbdb0c6
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 26 14:27:39 2020
 // Update Count     : 4472
+// Last Modified On : Fri Mar  6 17:26:45 2020
+// Update Count     : 4474
 //
 …
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
+// %token SUSPEND RESUME                                                                        // CFA
+// %token RESUME                                                                        // CFA
+%token SUSPEND                                                                  // CFA
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 …
         conditional_expression
         | unary_expression assignment_operator assignment_expression
+                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+                {
+                        if ( $2 == OperKinds::AtAssn ) {
+                                SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
+                        } else {
+                                $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
+                        } // if
+                }
         | unary_expression '=' '{' initializer_list_opt comma_opt '}'
                 { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
 …
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
+        // | SUSPEND ';'
+        //      { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        // | SUSPEND compound_statement ';'
+        //      { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND ';'
+                { $$ = new StatementNode( build_suspend( nullptr ) ); }
+        | SUSPEND compound_statement
+                { $$ = new StatementNode( build_suspend( $2 ) ); }
+        | SUSPEND COROUTINE ';'
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
+        | SUSPEND COROUTINE compound_statement
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
+        | SUSPEND GENERATOR ';'
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
+        | SUSPEND GENERATOR compound_statement
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
 …
 aggregate_control:                                                                              // CFA
         GENERATOR
                 { SemanticError( yylloc, "generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                { yyy = true; $$ = AggregateDecl::Generator; }
         | MONITOR GENERATOR
                 { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }

src/SynTree/Declaration.h

-                      rc4fd4ef
+                      rbbdb0c6
         bool is_coroutine() { return kind == Coroutine; }
+        bool is_monitor() { return kind == Monitor; }
+        bool is_thread() { return kind == Thread; }
+        bool is_generator() { return kind == Generator; }
+        bool is_monitor  () { return kind == Monitor  ; }
+        bool is_thread   () { return kind == Thread   ; }
         virtual StructDecl * clone() const override { return new StructDecl( *this ); }

src/SynTree/Mutator.h

rc4fd4ef	rbbdb0c6
51	51	virtual Statement * mutate( CatchStmt * catchStmt ) = 0;
52	52	virtual Statement * mutate( FinallyStmt * catchStmt ) = 0;
	53	virtual Statement * mutate( SuspendStmt * suspendStmt ) = 0;
53	54	virtual Statement * mutate( WaitForStmt * waitforStmt ) = 0;
54	55	virtual Declaration * mutate( WithStmt * withStmt ) = 0;

src/SynTree/Statement.cc

-                      rc4fd4ef
+                      rbbdb0c6
+}
+SuspendStmt::SuspendStmt( const SuspendStmt & other )
+        : Statement( other )
+        , then( maybeClone(other.then) )
+{}
+SuspendStmt::~SuspendStmt() {
+        delete then;
+}
+void SuspendStmt::print( std::ostream & os, Indenter indent ) const {
+        os << "Suspend Statement";
+        switch (type) {
+                case None     : os << " with implicit target"; break;
+                case Generator: os << " for generator"       ; break;
+                case Coroutine: os << " for coroutine"       ; break;
+        }
+        os << endl;
+        indent += 1;
+        if(then) {
+                os << indent << " with post statement :" << endl;
+                then->print( os, indent + 1);
+        }
+}
 WaitForStmt::WaitForStmt() : Statement() {
         timeout.time      = nullptr;

src/SynTree/Statement.h

-                      rc4fd4ef
+                      rbbdb0c6
 };
+class SuspendStmt : public Statement {
+  public:
+        CompoundStmt * then = nullptr;
+        enum Type { None, Coroutine, Generator } type = None;
+        SuspendStmt() = default;
+        SuspendStmt( const SuspendStmt & );
+        virtual ~SuspendStmt();
+        virtual SuspendStmt * clone() const override { return new SuspendStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
 class WaitForStmt : public Statement {
   public:

src/SynTree/SynTree.h

rc4fd4ef	rbbdb0c6
54	54	class CatchStmt;
55	55	class FinallyStmt;
	56	class SuspendStmt;
56	57	class WaitForStmt;
57	58	class WithStmt;

src/SynTree/Visitor.h

rc4fd4ef	rbbdb0c6
78	78	virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
79	79	virtual void visit( const FinallyStmt * finallyStmt ) = 0;
	80	virtual void visit( SuspendStmt * node ) { visit( const_cast<const SuspendStmt *>(node) ); }
	81	virtual void visit( const SuspendStmt * suspendStmt ) = 0;
80	82	virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
81	83	virtual void visit( const WaitForStmt * waitforStmt ) = 0;

tests/concurrent/coroutineYield.cfa

rc4fd4ef	rbbdb0c6
33	33	sout \| "Coroutine 2";
34	34	#endif
35		suspend();
	35	suspend;
36	36	}
37	37	}

tests/coroutine/.expect/fmtLines.txt

-                      rc4fd4ef
+                      rbbdb0c6
 {                                                         // f  or n  ewli
 ne c  hara  cter  s                                     su
 spen  d();                                      if   ( fm
 t.ch   !=   '\n'   ) b  reak
 ;               /  / ig  nore   new  line
                                   } //   for                              sout
  | f  mt.c  h;                                                  //
 prin  t ch  arac  ter                   }
 // f  or                        sou  t |   "  "
 ;                                                               //   prin  t bl
 ock   sepa  rato  r             }   //
 for             sou  t |   nl;
                                   // p  rint   gro  up s
 epar  ator      } /  / fo  r} /
 / ma  invo  id p  rt(   Form
 at &   fmt  , ch  ar c  h )
 {      fmt  .ch   = ch  ;
  res  ume(   fmt   );}   //
 prti  nt m  ain(  ) {     Form
 at f  mt;         char   ch;    for
  ( ;  ; )   {           s  in |   ch;
                                                                                 //   rea  d on
 e ch  arac  ter     if   ( e
 of(   sin   ) )   brea  k;
                                         //   eof   ?            p  rt(
 fmt,   ch   );  }   //   for}
  //   main  // L  ocal   Var
 iabl  es:   ////   tab  -wid
 th:   4 //  // c  ompi  le-c
 omma  nd:   "cfa   fmt  Line
 s.cf  a" /  ///   End:   //
+spen  d;                                        i  f (   fmt.
+ch !  = '\  n' )   bre  ak;
+        //   igno  re n  ewli  ne
+                }   // f  or                            so  ut |
+ fmt  .ch;                                                      /  / pr
+int   char  acte  r                       } //
+ for                    s  out   | "    ";
+                                                        /  / pr  int   bloc
+k se  para  tor         } /  / fo
+r               s  out   | nl  ;
+                //   pri  nt g  roup   sep
+arat  or        }   //   for}   //
+main  void   prt  ( Fo  rmat
+ & f  mt,   char   ch   ) {
+   f  mt.c  h =   ch;      r
+esum  e( f  mt )  ;} /  / pr
+tint   mai  n()   {     Fo  rmat
+ fmt  ; ch  ar c  h;    f  or (
+ ;;   ) {               sin   | c  h;
+                                                                  // r  ead   one
+char  acte  r       if (   eof
+( si  n )   ) br  eak;
+                        /  / eo  f ?            prt  ( fm
+t, c  h );      } /  / fo  r} /
+/ ma  in//   Loc  al V  aria
+bles  : //  // t  ab-w  idth
+: 4   ////   com  pile  -com
+mand  : "c  fa f  mtLi  nes.
+cfa"   ///  / En  d: /  /

tests/coroutine/.in/fmtLines.txt

rc4fd4ef	rbbdb0c6
35	35	for ( fmt.b = 0; fmt.b < 4; fmt.b += 1 ) { // blocks of 4 characters
36	36	for ( ;; ) { // for newline characters
37		suspend();
	37	suspend;
38	38	if ( fmt.ch != '\n' ) break; // ignore newline
39	39	} // for

tests/coroutine/cntparens.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
+//
 // cntparens.cfa -- match left/right parenthesis
 //
+//
 // Author           : Peter A. Buhr
 // Created On       : Sat Apr 20 11:04:45 2019
 …
 // Last Modified On : Sat Apr 20 11:06:21 2019
 // Update Count     : 1
 //
+//
 #include <fstream.hfa>
 …
 void main( CntParens & cpns ) with( cpns ) {
         for ( ; ch == '('; cnt += 1 ) {                                         // left parenthesis
                 suspend();
+                suspend;
+        }
         for ( ; ch == ')' && cnt > 1; cnt -= 1 ) {                      // right parenthesis
                 suspend();
+                suspend;
+        }
         status = ch == ')' ? Match : Error;
 } // main
 void ?{}( CntParens & cpns ) with( cpns ) { status = Cont; cnt = 0; }

tests/coroutine/devicedriver.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // devicedriver.cfa --
 //
+//
+// devicedriver.cfa --
+//
 // Author           : Peter A. Buhr
 // Created On       : Sat Mar 16 15:30:34 2019
 …
 // Last Modified On : Sat Apr 20 09:07:19 2019
 // Update Count     : 90
 //
+//
 #include <fstream.hfa>
 …
 void checkCRC( Driver & d, unsigned int sum ) with( d ) {
         suspend();
+        suspend;
         unsigned short int crc = byte << 8;                                     // sign extension over written
         suspend();
+        suspend;
         // prevent sign extension for signed char
         status = (crc | (unsigned char)byte) == sum ? MSG : ECRC;
 …
                 status = CONT;
                 unsigned int lnth = 0, sum = 0;
                 while ( byte != STX ) suspend();
+                while ( byte != STX ) suspend;
           emsg: for () {
                         suspend();
+                        suspend;
                         choose ( byte ) {                                                       // process byte
                           case STX:
                                 status = ESTX; suspend(); continue msg;
+                                status = ESTX; suspend; continue msg;
                           case ETX:
                                 break emsg;
                           case ESC:
                                 suspend();
+                                suspend;
                         } // choose
                         if ( lnth >= MaxMsg ) {                                         // buffer full ?
                                 status = ELNTH; suspend(); continue msg;
+                                status = ELNTH; suspend; continue msg;
                         } // if
                         msg[lnth++] = byte;
 …
                 msg[lnth] = '\0';                                                               // terminate string
                 checkCRC( d, sum );                                                             // refactor CRC check
                 suspend();
+                suspend;
         } // for
 } // main

tests/coroutine/fibonacci.cfa

-                      rc4fd4ef
+                      rbbdb0c6
         int fn1, fn2;                                                                           // retained between resumes
         fn = 0;  fn1 = fn;                                                                      // 1st case
         suspend();                                                                                      // restart last resume
+        suspend;                                                                                        // restart last resume
         fn = 1;  fn2 = fn1;  fn1 = fn;                                          // 2nd case
         suspend();                                                                                      // restart last resume
+        suspend;                                                                                        // restart last resume
         for () {
                 fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn;                  // general case
                 suspend();                                                                              // restart last resume
+                suspend;                                                                                // restart last resume
         } // for
+}

tests/coroutine/fibonacci_1.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 // Last Modified On : Thu Mar 21 08:10:45 2019
 // Update Count     : 25
 //
+//
 #include <fstream.hfa>
 …
         [fn1, fn] = [0, 1];                                                                     // precompute first two states
         for () {
                 suspend();                                                                              // restart last resume
+                suspend;                                                                                // restart last resume
                 [fn1, fn] = [fn, fn1 + fn];                                             // general case
         } // for

tests/coroutine/fmtLines.cfa

rc4fd4ef	rbbdb0c6
27	27	for ( b = 0; b < 4; b += 1 ) { // blocks of 4 characters
28	28	for () { // for newline characters
29		suspend();
	29	suspend;
30	30	if ( ch != '\n' ) break; // ignore newline
31	31	} // for

tests/coroutine/raii.cfa

rc4fd4ef	rbbdb0c6
39	39	Raii raii = { "Coroutine" };
40	40	sout \| "Before Suspend";
41		suspend();
	41	suspend;
42	42	sout \| "After Suspend";
43	43	}

tests/coroutine/runningTotal.cfa

rc4fd4ef	rbbdb0c6
25	25	void update( RunTotal & rntl, int input ) with( rntl ) { // helper
26	26	total += input; // remember between activations
27		suspend(); // inactivate on stack
	27	suspend; // inactivate on stack
28	28	}
29	29

tests/coroutine/suspend_then.cfa

-                      rc4fd4ef
+                      rbbdb0c6
 #include <fstream.hfa>
-#include <coroutine.hfa>
+void then() {
+        sout | "Then!";
+}
+coroutine Fibonacci { int fn; };                                                // used for communication
+generator Fibonacci {
+        int fn;                                                                         // used for communication
+        int fn1, fn2;                                                           // retained between resumes
+};
 void main( Fibonacci & fib ) with( fib ) {                              // called on first resume
-        int fn1, fn2;                                                           // retained between resumes
         fn = 0;  fn1 = fn;                                                      // 1st case
         suspend_then(then);                                                     // restart last resume
+        suspend { sout | "Then!"; }                                             // restart last resume
         fn = 1;  fn2 = fn1;  fn1 = fn;                                  // 2nd case
         suspend_then(then);                                                     // restart last resume
+        suspend { sout | "Then!"; }                                             // restart last resume
         for () {
                 fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn;                  // general case
                 suspend_then(then);                                             // restart last resume
+                suspend { sout | "Then!"; }                                     // restart last resume
         } // for
+}

tests/errors/.expect/completeType.txt

-                      rc4fd4ef
+                      rbbdb0c6
     void
+  )
   Environment:( _83_4_DT ) -> instance of struct A with body 0 (no widening)
+  Environment:( _85_4_DT ) -> instance of struct A with body 0 (no widening)
 …
     void
+  )
   Environment:( _83_4_DT ) -> instance of struct B with body 1 (no widening)
+  Environment:( _85_4_DT ) -> instance of struct B with body 1 (no widening)
 …
           void
+        )
         Environment:( _102_0_T ) -> instance of type T (not function type) (no widening)
+        Environment:( _104_0_T ) -> instance of type T (not function type) (no widening)
       Could not satisfy assertion:
 ?=?: pointer to function
         ... with parameters
           reference to instance of type _102_0_T (not function type)
           instance of type _102_0_T (not function type)
+          reference to instance of type _104_0_T (not function type)
+          instance of type _104_0_T (not function type)
         ... returning
           _retval__operator_assign: instance of type _102_0_T (not function type)
+          _retval__operator_assign: instance of type _104_0_T (not function type)
           ... with attributes:
             Attribute with name: unused

Context Navigation

Changes in / [c4fd4ef:bbdb0c6]

Legend:

Download in other formats: