Changes in / [1ed9cb63:8a039be]

Files:

• doc/user/user.tex (modified) (7 diffs)
• libcfa/src/fstream.cfa (modified) (13 diffs)
• libcfa/src/fstream.hfa (modified) (6 diffs)
• libcfa/src/iostream.cfa (modified) (4 diffs)
• libcfa/src/iostream.hfa (modified) (6 diffs)
• libcfa/src/strstream.cfa (modified) (5 diffs)
• libcfa/src/strstream.hfa (modified) (2 diffs)
• src/AST/Pass.hpp (modified) (2 diffs)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Pass.proto.hpp (modified) (1 diff)
• src/AST/TranslationUnit.hpp (modified) (1 diff)
• src/AST/porting.md (modified) (1 diff)
• src/CodeTools/DeclStats.cc (modified) (3 diffs)
• src/Common/DeclStats.cpp (deleted)
• src/Common/DeclStats.hpp (deleted)
• src/Common/ResolvProtoDump.cpp (deleted)
• src/Common/ResolvProtoDump.hpp (deleted)
• src/Common/module.mk (modified) (2 diffs)
• src/InitTweak/GenInit.cc (modified) (3 diffs)
• src/InitTweak/GenInit.h (modified) (2 diffs)
• src/Parser/parser.yy (modified) (14 diffs)
• src/main.cc (modified) (5 diffs)
• tests/concurrent/semaphore.cfa (modified) (2 diffs)
• tests/concurrent/sleep.cfa (modified) (3 diffs)
• tests/io/io-acquire.cfa (modified) (5 diffs)
• tests/linking/io-acquire.cfa (modified) (1 diff)
• tests/pybin/test_run.py (modified) (1 diff)
• tests/test.py (modified) (6 diffs)

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun Oct 10 12:45:00 2021
-%% Update Count     : 5095
+%% Last Modified On : Mon May 31 09:03:34 2021
+%% Update Count     : 5071
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -4444 +4444 @@
 \CFA provides a fine-grained solution where a \Index{recursive lock} is acquired and released indirectly via a manipulator ©acquire© or instantiating an \Index{RAII} type specific for the kind of stream: ©osacquire©\index{ostream@©ostream©!osacquire@©osacquire©} for output streams and ©isacquire©\index{isacquire@©isacquire©}\index{istream@©istream©!isacquire@©isacquire©} for input streams.
 
-The common usage is the short form of the mutex statement\index{ostream@©ostream©!mutex@©mutex©} to lock a stream during a single cascaded I/O expression, \eg:
-\begin{cfa}
-$\emph{thread\(_1\)}$ : ®mutex()® sout | "abc " | "def ";
-$\emph{thread\(_2\)}$ : ®mutex()® sout | "uvw " | "xyz ";
+The common usage is manipulator ©acquire©\index{ostream@©ostream©!acquire@©acquire©} to lock a stream during a single cascaded I/O expression, with the manipulator appearing as the first item in a cascade list, \eg:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
+$\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
 \end{cfa}
 Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
@@ -4466 +4466 @@
 In summary, the stream lock is acquired by the ©acquire© manipulator and implicitly released at the end of the cascaded I/O expression ensuring all operations in the expression occur atomically.
 
-To lock a stream across multiple I/O operations, he long form of the mutex statement is used, \eg:
-\begin{cfa}
-®mutex( sout )® {
+To lock a stream across multiple I/O operations, an object of type ©osacquire© or ©isacquire© is declared to implicitly acquire/release the stream lock providing mutual exclusion for the object's duration, \eg:
+\begin{cfa}
+{       // acquire sout for block duration
+        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
         sout | 1;
-        ®mutex() sout® | 2 | 3;                         $\C{// unnecessary, but ok because of recursive lock}$
+        sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
         sout | 4;
-} // implicitly release sout lock
-\end{cfa}
-Note, the unnecessary ©mutex© in the middle of the mutex statement, works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
+}       // implicitly release the lock when "acq" is deallocated
+\end{cfa}
+Note, the unnecessary ©acquire© manipulator works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
 Hence, calls to functions that also acquire a stream lock for their output do not result in \Index{deadlock}.
 
 The previous values written by threads 1 and 2 can be read in concurrently:
 \begin{cfa}
-®mutex( sin )® {
+{       // acquire sin lock for block duration
+        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
         int x, y, z, w;
         sin | x;
-        ®mutex() sin® | y | z;                          $\C{// unnecessary, but ok because of recursive lock}$
+        sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
         sin | w;
-} // implicitly release sin lock
+}       // implicitly release the lock when "acq" is deallocated
 \end{cfa}
 Again, the order of the reading threads is non-deterministic.
@@ -4491 +4493 @@
 \Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
 \begin{cfa}
-®mutex() sout® | "data:" | rtn( mon );  $\C{// mutex call on monitor}$
+sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
 \end{cfa}
 If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
@@ -4498 +4500 @@
 \begin{cfa}
 int ®data® = rtn( mon );
-mutex() sout | "data:" | ®data®;
+sout | acquire | "data:" | ®data®;
 \end{cfa}
 
@@ -4504 +4506 @@
 \section{String Stream}
 
-The stream types ©ostrstream© and ©istrstream© provide all the stream formatting capabilities to/from a C string rather than a stream file.
-\VRef[Figure]{f:StringStreamProcessing} shows writing (output) to and reading (input) from a C string.
-The only string stream operations different from a file stream are:
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-constructors to create a stream that writes to a write buffer (©ostrstream©) of ©size©, or reads from a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
-\begin{cfa}
-void ?{}( ostrstream &, char buf[], size_t size );
-void ?{}( istrstream & is, char buf[] );
-\end{cfa}
-\item
-\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
-\begin{cfa}
-ostrstream & write( ostrstream & os, FILE * stream = stdout );
-\end{cfa}
-There is no ©read© for ©istrstream©.
-\end{itemize}
-
+All the stream formatting capabilities are available to format text to/from a C string rather than to a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) and reading (input) from a C string.
 \begin{figure}
 \begin{cfa}
@@ -4534 +4520 @@
         double x = 12345678.9, y = 98765.4321e-11;
 
-        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
-        write( osstr ); $\C{// write string to stdout}$
-        printf( "%s", buf ); $\C{// same lines of output}$
-        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
-
-        char buf2[] = "12 14 15 3.5 7e4 abc"; $\C{// input buffer}$
+        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); $\C{// same lines of output}$
+        write( osstr );
+        printf( "%s", buf );
+        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
+
+        char buf2[] = "12 14 15 3.5 7e4"; $\C{// input buffer}$
         ®istrstream isstr = { buf2 };®
-        char s[10];
-        isstr | i | j | k | x | y | s;
-        sout  | i | j | k | x | y | s;
-}
-
-3 0x5          7 1.234568e+07 987.654n abc
-3 0x5          7 1.234568e+07 987.654n abc
-3 0x5          7 1.234568e+07 987.654n abc
-12 14 15 3.5 70000. abc
+        isstr | i | j | k | x | y;
+        sout | i | j | k | x | y;
+}
 \end{cfa}
 \caption{String Stream Processing}
 \label{f:StringStreamProcessing}
 \end{figure}
+
+\VRef[Figure]{f:StringStreamFunctions} shows the string stream operations.
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
+\end{itemize}
+The constructor functions:
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+create a bound stream to a write buffer (©ostrstream©) of ©size© or a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
+\end{itemize}
+
+\begin{figure}
+\begin{cfa}
+// *********************************** ostrstream ***********************************
+
+ostrstream & write( ostrstream & os, FILE * stream = stdout );
+
+void ?{}( ostrstream &, char buf[], size_t size );
+
+// *********************************** istrstream ***********************************
+
+void ?{}( istrstream & is, char buf[] );
+\end{cfa}
+\caption{String Stream Functions}
+\label{f:StringStreamFunctions}
+\end{figure}
+
 
 \begin{comment}

libcfa/src/fstream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 11:23:05 2021
-// Update Count     : 512
+// Last Modified On : Tue Sep 21 21:51:38 2021
+// Update Count     : 460
 //
 
@@ -28 +28 @@
 #define IO_MSG "I/O error: "
 
-// private
-void ?{}( ofstream & os, void * file ) with( os ) {
+void ?{}( ofstream & os, void * file ) with(os) {
         file$ = file;
         sepDefault$ = true;
@@ -36 +35 @@
         prt$ = false;
         sawNL$ = false;
+        acquired$ = false;
         sepSetCur$( os, sepGet( os ) );
         sepSet( os, " " );
@@ -41 +41 @@
 } // ?{}
 
-inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
-inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
-inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
-inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
-inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
-inline bool getNL$( ofstream & os ) { return os.sawNL$; }
-inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
-inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
-inline bool getPrt$( ofstream & os ) { return os.prt$; }
-inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
-
-inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
-inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
+// private
+bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ofstream & os ) { return os.sawNL$; }
+void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ofstream & os ) { return os.prt$; }
+void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
 
 // public
 void ?{}( ofstream & os ) { os.file$ = 0p; }
-void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
-void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
-void ^?{}( ofstream & os ) { close( os ); }
+
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
+        open( os, name, mode );
+} // ?{}
+
+void ?{}( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // ?{}
+
+void ^?{}( ofstream & os ) {
+        close( os );
+} // ^?{}
 
 void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
@@ -100 +107 @@
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
+        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
 
-bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
-void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
-int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
+bool fail( ofstream & os ) {
+        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
+} // fail
+
+void clear( ofstream & os ) {
+        clearerr( (FILE *)(os.file$) );
+} // clear
+
+int flush( ofstream & os ) {
+        return fflush( (FILE *)(os.file$) );
+} // flush
 
 void open( ofstream & os, const char name[], const char mode[] ) {
-        FILE * file;
-    for ( cnt; 10 ) {
-                errno = 0;
-                file = fopen( name, mode );
-          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
-          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
-    } // for
+        FILE * file = fopen( name, mode );
         if ( file == 0p ) {
                 throw (Open_Failure){ os };
@@ -121 +131 @@
 } // open
 
-void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
-
-void close( ofstream & os ) with( os ) {
+void open( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // open
+
+void close( ofstream & os ) with(os) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
 
-        int ret;
-    for ( cnt; 10 ) {
-                errno = 0;
-                ret = fclose( (FILE *)(file$) );
-          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
-          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
-    } // for
-        if ( ret == EOF ) {
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
                 throw (Close_Failure){ os };
                 // abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
-        file$ = 0p;                                                                                     // safety after close
+        file$ = 0p;
 } // close
 
@@ -157 +162 @@
         va_list args;
         va_start( args, format );
-                
-        int len;
-    for ( cnt; 10 ) {
-                errno = 0;
-                len = vfprintf( (FILE *)(os.file$), format, args );
-          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
-          if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
-    } // for
+        int len = vfprintf( (FILE *)(os.file$), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file$) ) ) {
@@ -177 +175 @@
 } // fmt
 
+inline void acquire( ofstream & os ) with(os) {
+        lock( lock$ );                                                                          // may increase recursive lock
+        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
+        else unlock( lock$ );                                                           // unwind recursive lock at start
+} // acquire
+
+inline void release( ofstream & os ) {
+        unlock( os.lock$ );
+} // release
+
+void ?{}( osacquire & acq, ofstream & os ) { lock( os.lock$ ); &acq.os = &os; }
+void ^?{}( osacquire & acq ) { release( acq.os ); }
+
 static ofstream soutFile = { (FILE *)stdout };
 ofstream & sout = soutFile, & stdout = soutFile;
@@ -194 +205 @@
         flush( os );
         return os;
+        // (ofstream &)(os | '\n');
+        // setPrt$( os, false );                                                        // turn off
+        // setNL$( os, true );
+        // flush( os );
+        // return sepOff( os );                                                 // prepare for next line
 } // nl
 
@@ -201 +217 @@
 
 // private
-void ?{}( ifstream & is, void * file ) with( is ) {
+void ?{}( ifstream & is, void * file ) with(is) {
         file$ = file;
         nlOnOff$ = false;
-} // ?{}
-
-bool getANL$( ifstream & os ) { return os.nlOnOff$; }
-
-inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
-inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
+        acquired$ = false;
+} // ?{}
 
 // public
 void ?{}( ifstream & is ) { is.file$ = 0p; }
-void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
-void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
-void ^?{}( ifstream & is ) { close( is ); }
-
-bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
-void clear( ifstream & is ) { clearerr( (FILE *)(is.file$) ); }
+
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
+        open( is, name, mode );
+} // ?{}
+
+void ?{}( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // ?{}
+
+void ^?{}( ifstream & is ) {
+        close( is );
+} // ^?{}
 
 void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
 void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
-
-void ends( ifstream & is ) {}
-
-bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
+bool getANL( ifstream & os ) { return os.nlOnOff$; }
+
+bool fail( ifstream & is ) {
+        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
+} // fail
+
+void clear( ifstream & is ) {
+        clearerr( (FILE *)(is.file$) );
+} // clear
+
+void ends( ifstream & is ) {
+        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
+} // ends
+
+bool eof( ifstream & is ) {
+        return feof( (FILE *)(is.file$) );
+} // eof
 
 void open( ifstream & is, const char name[], const char mode[] ) {
-        FILE * file;
-    for ( cnt; 10 ) {
-                errno = 0;
-                file = fopen( name, mode );
-          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
-          if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" );
-    } // for
+        FILE * file = fopen( name, mode );
         if ( file == 0p ) {
                 throw (Open_Failure){ is };
@@ -242 +267 @@
 } // open
 
-void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
-
-void close( ifstream & is ) with( is ) {
+void open( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // open
+
+void close( ifstream & is ) with(is) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdin ) return;
 
-        int ret;
-    for ( cnt; 10 ) {
-                errno = 0;
-                ret = fclose( (FILE *)(file$) );
-          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
-          if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" );
-    } // for
-        if ( ret == EOF ) {
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
                 throw (Close_Failure){ is };
                 // abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
-        file$ = 0p;                                                                                     // safety after close
+        file$ = 0p;
 } // close
 
@@ -288 +308 @@
 int fmt( ifstream & is, const char format[], ... ) {
         va_list args;
+
         va_start( args, format );
-
-        int len;
-    for () {                                                                                    // no check for EINTR limit waiting for keyboard input
-                errno = 0;
-                len = vfscanf( (FILE *)(is.file$), format, args );
-          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
-    } // for
+        int len = vfscanf( (FILE *)(is.file$), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file$) ) ) {
@@ -304 +319 @@
         return len;
 } // fmt
+
+inline void acquire( ifstream & is ) with(is) {
+        lock( lock$ );                                                                          // may increase recursive lock
+        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
+        else unlock( lock$ );                                                           // unwind recursive lock at start
+} // acquire
+
+inline void release( ifstream & is ) {
+        unlock( is.lock$ );
+} // release
+
+void ?{}( isacquire & acq, ifstream & is ) { lock( is.lock$ ); &acq.is = &is; }
+void ^?{}( isacquire & acq ) { release( acq.is ); }
 
 static ifstream sinFile = { (FILE *)stdin };

libcfa/src/fstream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 09:37:32 2021
-// Update Count     : 243
+// Last Modified On : Wed Jul 28 07:35:50 2021
+// Update Count     : 234
 //
 
@@ -36 +36 @@
         char tupleSeparator$[ofstream_sepSize];
         multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ofstream
 
@@ -52 +53 @@
 void setPrt$( ofstream &, bool );
 
-void lock( ofstream & );
-void unlock( ofstream & );
-
 // public
 void sepOn( ofstream & );
@@ -77 +75 @@
 void open( ofstream &, const char name[] );
 void close( ofstream & );
-
 ofstream & write( ofstream &, const char data[], size_t size );
+
+void acquire( ofstream & );
+void release( ofstream & );
+
+void lock( ofstream & );
+void unlock( ofstream & );
+
+struct osacquire {
+        ofstream & os;
+};
+void ?{}( osacquire & acq, ofstream & );
+void ^?{}( osacquire & acq );
 
 void ?{}( ofstream & );
@@ -101 +110 @@
         bool nlOnOff$;
         multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ifstream
 
 // Satisfies istream
-
-// private
-bool getANL$( ifstream & );
-
-void lock( ifstream & );
-void unlock( ifstream & );
 
 // public
 void nlOn( ifstream & );
 void nlOff( ifstream & );
+bool getANL( ifstream & );
 void ends( ifstream & );
 int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
@@ -123 +128 @@
 void open( ifstream & is, const char name[] );
 void close( ifstream & is );
-
 ifstream & read( ifstream & is, char data[], size_t size );
 ifstream & ungetc( ifstream & is, char c );
+
+void acquire( ifstream & is );
+void release( ifstream & is );
+
+struct isacquire {
+        ifstream & is;
+};
+void ?{}( isacquire & acq, ifstream & is );
+void ^?{}( isacquire & acq );
 
 void ?{}( ifstream & is );

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 09:28:17 2021
-// Update Count     : 1345
+// Last Modified On : Sat May 15 09:39:21 2021
+// Update Count     : 1342
 //
 
@@ -398 +398 @@
                 return os;
         } // nlOff
+} // distribution
+
+forall( ostype & | ostream( ostype ) ) {
+        ostype & acquire( ostype & os ) {
+                acquire( os );                                                                  // call void returning
+                return os;
+        } // acquire
 } // distribution
 
@@ -822 +829 @@
                         fmt( is, "%c", &temp );                                         // must pass pointer through varg to fmt
                         // do not overwrite parameter with newline unless appropriate
-                        if ( temp != '\n' || getANL$( is ) ) { c = temp; break; }
+                        if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
                         if ( eof( is ) ) break;
                 } // for
@@ -1028 +1035 @@
                 return is;
         } // nlOff
+} // distribution
+
+forall( istype & | istream( istype ) ) {
+        istype & acquire( istype & is ) {
+                acquire( is );                                                                  // call void returning
+                return is;
+        } // acquire
 } // distribution
 

libcfa/src/iostream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 10:02:07 2021
-// Update Count     : 407
+// Last Modified On : Wed Apr 28 20:37:56 2021
+// Update Count     : 401
 //
 
@@ -58 +58 @@
         void close( ostype & );
         ostype & write( ostype &, const char [], size_t );
+        void acquire( ostype & );                                                       // concurrent access
 }; // ostream
 
@@ -141 +142 @@
         ostype & nlOn( ostype & );
         ostype & nlOff( ostype & );
+} // distribution
+
+forall( ostype & | ostream( ostype ) ) {
+        ostype & acquire( ostype & );
 } // distribution
 
@@ -291 +296 @@
 
 trait basic_istream( istype & ) {
-        // private
-        bool getANL$( istype & );                                                       // get scan newline (on/off)
-        // public
+        bool getANL( istype & );                                                        // get scan newline (on/off)
         void nlOn( istype & );                                                          // read newline
         void nlOff( istype & );                                                         // scan newline
+
         void ends( istype & os );                                                       // end of output statement
         int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
@@ -308 +312 @@
         void close( istype & is );
         istype & read( istype &, char [], size_t );
+        void acquire( istype & );                                                       // concurrent access
 }; // istream
 
@@ -374 +379 @@
 } // distribution
 
+forall( istype & | istream( istype ) ) {
+        istype & acquire( istype & );
+} // distribution
+
 // *********************************** manipulators ***********************************
 

libcfa/src/strstream.cfa

@@ -10 +10 @@
 // Created On       : Thu Apr 22 22:24:35 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 16:13:20 2021
-// Update Count     : 101
+// Last Modified On : Tue Apr 27 20:59:53 2021
+// Update Count     : 78
 // 
 
 #include "strstream.hfa"
-#include "fstream.hfa"                                                                  // abort
 
 #include <stdio.h>                                                                              // vsnprintf
@@ -31 +30 @@
 
 // private
-inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
-inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
-inline void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
-inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
-inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
-inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
-inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
-inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
-inline bool getPrt$( ostrstream & os ) { return os.prt$; }
-inline void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
+bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
+void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ostrstream & os ) { return os.sawNL$; }
+void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ostrstream & os ) { return os.prt$; }
+void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
 
 // public
@@ -129 +128 @@
 // *********************************** istrstream ***********************************
 
-// private
-bool getANL$( istrstream & is ) { return is.nlOnOff$; }
 
 // public
@@ -139 +136 @@
 } // ?{}
 
+bool getANL( istrstream & is ) { return is.nlOnOff$; }
 void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
 void nlOff( istrstream & is ) { is.nlOnOff$ = false; }
 
-void ends( istrstream & is ) {}
-bool eof( istrstream & is ) { return false; }
+void ends( istrstream & is ) {
+} // ends
 
-int fmt( istrstream & is, const char format[], ... ) with(is) {
-        va_list args;
-        va_start( args, format );
-        // THIS DOES NOT WORK BECAUSE VSSCANF RETURNS NUMBER OF VALUES READ VERSUS BUFFER POSITION SCANNED.
-        int len = vsscanf( buf$ + cursor$, format, args );
-        va_end( args );
-        if ( len == EOF ) {
-                abort | IO_MSG "invalid read";
-        } // if
-        // SKULLDUGGERY: This hack skips over characters read by vsscanf by moving to the next whitespace but it does not
-        // handle C reads with wdi manipulators that leave the cursor at a non-whitespace character.
-        for ( ; buf$[cursor$] != ' ' && buf$[cursor$] != '\t' && buf$[cursor$] != '\0'; cursor$ += 1 ) {
-                //printf( "X \'%c\'\n", buf$[cursor$] );
-        } // for
-        if ( buf$[cursor$] != '\0' ) cursor$ += 1;      // advance to whitespace
-        return len;
-} // fmt
+int eof( istrstream & is ) {
+        return 0;
+} // eof
 
 istrstream &ungetc( istrstream & is, char c ) {
@@ -170 +154 @@
 } // ungetc
 
+int fmt( istrstream & is, const char format[], ... ) {
+        va_list args;
+        va_start( args, format );
+        // This does not work because vsscanf does not return buffer position.
+        int len = vsscanf( is.buf$ + is.cursor$, format, args );
+        va_end( args );
+        if ( len == EOF ) {
+                int j;
+                printf( "X %d%n\n", len, &j );
+        } // if
+        is.cursor$ += len;
+        return len;
+} // fmt
+
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/strstream.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr 22 22:20:59 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 10 10:14:22 2021
-// Update Count     : 47
+// Last Modified On : Tue Apr 27 20:58:50 2021
+// Update Count     : 41
 // 
 
@@ -85 +85 @@
 // Satisfies basic_istream
 
-// private
-bool getANL$( istrstream & );
-
 // public
+bool getANL( istrstream & );
 void nlOn( istrstream & );
 void nlOff( istrstream & );
 void ends( istrstream & );
+int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+istrstream & ungetc( istrstream & is, char c );
+int eof( istrstream & is );
 
-int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
-istrstream & ungetc( istrstream &, char );
-bool eof( istrstream & );
-
-void ?{}( istrstream &, char buf[] );
+void ?{}( istrstream & is, char buf[] );
 
 // Local Variables: //

src/AST/Pass.hpp

@@ -348 +348 @@
 
         /// When this node is finished being visited, restore the value of a variable
-        /// You may assign to the return value to set the new value in the same statement.
         template< typename T >
-        T& GuardValue( T& val ) {
+        void GuardValue( T& val ) {
                 at_cleanup( [ val ]( void * newVal ) {
                         * static_cast< T * >( newVal ) = val;
                 }, static_cast< void * >( & val ) );
-                return val;
         }
 
@@ -396 +394 @@
 };
 
-/// Used to get a pointer to the wrapping TranslationUnit.
-struct WithConstTranslationUnit {
-        const TranslationUnit * translationUnit = nullptr;
-
-        const TranslationUnit & transUnit() const {
-                assertf( translationUnit, "WithConstTranslationUnit not set-up." );
-                return *translationUnit;
-        }
-};
-
 }
 

src/AST/Pass.impl.hpp

@@ -420 +420 @@
 template< typename core_t >
 inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
-        if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
-                ValueGuard<const TranslationUnit *> guard( *ptr );
-                *ptr = &unit;
-                return ast::accept_all( unit.decls, visitor );
-        } else {
-                return ast::accept_all( unit.decls, visitor );
-        }
+        return ast::accept_all( unit.decls, visitor );
 }
 

src/AST/Pass.proto.hpp

@@ -426 +426 @@
         } // namespace forall
 
-        // For passes that need access to the global context. Sreaches `translationUnit`
-        namespace translation_unit {
-                template<typename core_t>
-                static inline auto get_cptr( core_t & core, int )
-                                -> decltype( &core.translationUnit ) {
-                        return &core.translationUnit;
-                }
-
-                template<typename core_t>
-                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
-                        return nullptr;
-                }
-        }
-
         template<typename core_t>
         static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {

src/AST/TranslationUnit.hpp

@@ -26 +26 @@
         std::list< ptr< Decl > > decls;
 
-        struct Global {
+        struct Globals {
                 std::map< UniqueId, Decl * > idMap;
 
-                ptr<Type> sizeType;
+                const Type * sizeType;
                 const FunctionDecl * dereference;
                 const StructDecl * dtorStruct;

src/AST/porting.md

@@ -98 +98 @@
         * `Initializer` => `ast::Init`
     * `Statement` => `ast::Stmt`
-    * `ReferenceToType` => `ast::BaseInstType`
         * any field names should follow a similar renaming
   * because they don't really belong to `Type` (and for consistency with `Linkage::Spec`):

src/CodeTools/DeclStats.cc

@@ -156 +156 @@
                 /// number of counting bins for linkages
                 static const unsigned n_named_specs = 8;
-                /// Mapping function from linkage to bin.
-                static unsigned linkage_index( LinkageSpec::Spec spec ) {
-                        switch ( spec ) {
-                        case LinkageSpec::Intrinsic:  return 0;
-                        case LinkageSpec::C:          return 1;
-                        case LinkageSpec::Cforall:    return 2;
-                        case LinkageSpec::AutoGen:    return 3;
-                        case LinkageSpec::Compiler:   return 4;
-                        case LinkageSpec::BuiltinCFA: return 5;
-                        case LinkageSpec::BuiltinC:   return 6;
-                        default:                      return 7;
-                        }
-                }
+                /// map from total number of specs to bins
+                static const unsigned ind_for_linkage[16];
 
                 Stats for_linkage[n_named_specs];            ///< Stores separate stats per linkage
@@ -377 +366 @@
                         const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
                         if ( seen_names.insert( mangleName ).second ) {
-                                Stats& stats = for_linkage[ linkage_index( decl->linkage ) ];
+                                Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
 
                                 ++stats.n_decls;
@@ -538 +527 @@
         };
 
+        const unsigned DeclStats::ind_for_linkage[]
+                = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
+
         void printDeclStats( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<DeclStats> stats;

src/Common/module.mk

@@ -22 +22 @@
       Common/CompilerError.h \
       Common/Debug.h \
-      Common/DeclStats.hpp \
-      Common/DeclStats.cpp \
       Common/ErrorObjects.h \
       Common/Eval.cc \
@@ -35 +33 @@
       Common/PassVisitor.proto.h \
       Common/PersistentMap.h \
-      Common/ResolvProtoDump.hpp \
-      Common/ResolvProtoDump.cpp \
       Common/ScopedMap.h \
       Common/SemanticError.cc \

src/InitTweak/GenInit.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Oct 25 13:53:00 2021
-// Update Count     : 186
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Dec 13 23:15:10 2019
+// Update Count     : 184
 //
 #include "GenInit.h"
@@ -24 +24 @@
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
-#include "AST/Pass.hpp"
 #include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
@@ -295 +294 @@
         }
 
-namespace {
-
-#       warning Remove the _New suffix after the conversion is complete.
-        struct HoistArrayDimension_NoResolve_New final :
-                        public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting,
-                        public ast::WithGuards, public ast::WithConstTranslationUnit,
-                        public ast::WithVisitorRef<HoistArrayDimension_NoResolve_New> {
-                void previsit( const ast::ObjectDecl * decl );
-                const ast::DeclWithType * postvisit( const ast::ObjectDecl * decl );
-                // Do not look for objects inside there declarations (and type).
-                void previsit( const ast::AggregateDecl * ) { visit_children = false; }
-                void previsit( const ast::NamedTypeDecl * ) { visit_children = false; }
-                void previsit( const ast::FunctionType * ) { visit_children = false; }
-
-                const ast::Type * hoist( const ast::Type * type );
-
-                ast::Storage::Classes storageClasses;
-        };
-
-        void HoistArrayDimension_NoResolve_New::previsit(
-                        const ast::ObjectDecl * decl ) {
-                GuardValue( storageClasses ) = decl->storage;
-        }
-
-        const ast::DeclWithType * HoistArrayDimension_NoResolve_New::postvisit(
-                        const ast::ObjectDecl * objectDecl ) {
-                return mutate_field( objectDecl, &ast::ObjectDecl::type,
-                                hoist( objectDecl->type ) );
-        }
-
-        const ast::Type * HoistArrayDimension_NoResolve_New::hoist(
-                        const ast::Type * type ) {
-                static UniqueName dimensionName( "_array_dim" );
-
-                if ( !isInFunction() || storageClasses.is_static ) {
-                        return type;
-                }
-
-                if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        if ( nullptr == arrayType->dimension ) {
-                                return type;
-                        }
-
-                        if ( !Tuples::maybeImpure( arrayType->dimension ) ) {
-                                return type;
-                        }
-
-                        ast::ptr<ast::Type> dimType = transUnit().global.sizeType;
-                        assert( dimType );
-                        add_qualifiers( dimType, ast::CV::Qualifiers( ast::CV::Const ) );
-
-                        ast::ObjectDecl * arrayDimension = new ast::ObjectDecl(
-                                arrayType->dimension->location,
-                                dimensionName.newName(),
-                                dimType,
-                                new ast::SingleInit(
-                                        arrayType->dimension->location,
-                                        arrayType->dimension
-                                )
-                        );
-
-                        ast::ArrayType * mutType = ast::mutate( arrayType );
-                        mutType->dimension = new ast::VariableExpr(
-                                        arrayDimension->location, arrayDimension );
-                        declsToAddBefore.push_back( arrayDimension );
-
-                        mutType->base = hoist( mutType->base );
-                        return mutType;
-                }
-                return type;
-        }
-
-        struct ReturnFixer_New final :
-                        public ast::WithStmtsToAdd<>, ast::WithGuards {
-                void previsit( const ast::FunctionDecl * decl );
-                const ast::ReturnStmt * previsit( const ast::ReturnStmt * stmt );
-        private:
-                const ast::FunctionDecl * funcDecl = nullptr;
-        };
-
-        void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) {
-                GuardValue( funcDecl ) = decl;
-        }
-
-        const ast::ReturnStmt * ReturnFixer_New::previsit(
-                        const ast::ReturnStmt * stmt ) {
-                auto & returns = funcDecl->returns;
-                assert( returns.size() < 2 );
-                // Hands off if the function returns a reference.
-                // Don't allocate a temporary if the address is returned.
-                if ( stmt->expr && 1 == returns.size() ) {
-                        ast::ptr<ast::DeclWithType> retDecl = returns.front();
-                        if ( isConstructable( retDecl->get_type() ) ) {
-                                // Explicitly construct the return value using the return
-                                // expression and the retVal object.
-                                assertf( "" != retDecl->name,
-                                        "Function %s has unnamed return value.\n",
-                                        funcDecl->name.c_str() );
-
-                                auto retVal = retDecl.strict_as<ast::ObjectDecl>();
-                                if ( auto varExpr = stmt->expr.as<ast::VariableExpr>() ) {
-                                        // Check if the return statement is already set up.
-                                        if ( varExpr->var == retVal ) return stmt;
-                                }
-                                ast::ptr<ast::Stmt> ctorStmt = genCtorDtor(
-                                        retVal->location, "?{}", retVal, stmt->expr );
-                                assertf( ctorStmt,
-                                        "ReturnFixer: genCtorDtor returned nllptr: %s / %s",
-                                        toString( retVal ).c_str(),
-                                        toString( stmt->expr ).c_str() );
-                                        stmtsToAddBefore.push_back( ctorStmt );
-
-                                // Return the retVal object.
-                                ast::ReturnStmt * mutStmt = ast::mutate( stmt );
-                                mutStmt->expr = new ast::VariableExpr(
-                                        stmt->location, retDecl );
-                                return mutStmt;
-                        }
-                }
-                return stmt;
-        }
-
-} // namespace
-
-        void genInit( ast::TranslationUnit & transUnit ) {
-                ast::Pass<HoistArrayDimension_NoResolve_New>::run( transUnit );
-                ast::Pass<ReturnFixer_New>::run( transUnit );
-        }
-
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<CtorDtor> ctordtor;

src/InitTweak/GenInit.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct 22 16:08:00 2021
-// Update Count     : 6
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:31:19 2017
+// Update Count     : 4
 //
 
@@ -27 +27 @@
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
-        void genInit( ast::TranslationUnit & translationUnit );
 
         /// Converts return statements into copy constructor calls on the hidden return variable

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 15 09:20:17 2021
-// Update Count     : 5163
+// Last Modified On : Sat Sep 11 08:20:44 2021
+// Update Count     : 5040
 //
 
@@ -31 +31 @@
 // from ANSI90 to ANSI11 C are marked with the comment "C99/C11".
 
-// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions. All of the
+// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions All of the
 // syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall (CFA), which
 // fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic
@@ -69 +69 @@
         // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
         //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
-        //    e.g., u"a" U"b" L"c" is disallowed.
+        //    i.e., u"a" U"b" L"c" is disallowed.
 
         if ( from[0] != '"' ) {                                                         // encoding ?
@@ -310 +310 @@
 %token ATassign                                                                                 // @=
 
-%type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
+%type<tok> identifier
+%type<tok> identifier_or_type_name  attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
@@ -326 +327 @@
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
-%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
+%type<en> argument_expression_list_opt  argument_expression                     default_initializer_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
@@ -558 +559 @@
         IDENTIFIER
         | quasi_keyword
-        ;
-
-identifier_at:
-        identifier
         | '@'                                                                                           // CFA
                 { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
@@ -696 +693 @@
         // empty
                 { $$ = nullptr; }
-        | argument_expression_list
-        ;
-
-argument_expression_list:
-        argument_expression
+        | argument_expression
         | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
@@ -738 +731 @@
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
-        | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+        | identifier fraction_constants_opt
                 {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
@@ -1091 +1084 @@
         comma_expression_opt ';'
                 { $$ = new StatementNode( build_expr( $1 ) ); }
-        | MUTEX '(' ')' comma_expression ';'
-                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
-                // { SemanticError( yylloc, "Mutex expression is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -1192 +1182 @@
 
 iteration_statement:
-        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
+        WHILE '(' push if_control_expression ')' statement pop
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
+        | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement         %prec THEN
-                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        | DO statement WHILE '(' comma_expression ')' ';'
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
-        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
-                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
-        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        | FOR '(' push for_control_expression_list ')' statement pop
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
-        | FOR '(' for_control_expression_list ')' statement     %prec THEN
-                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
-        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -1355 +1339 @@
 with_statement:
         WITH '(' tuple_expression_list ')' statement
-                { $$ = new StatementNode( build_with( $3, $5 ) ); }
+                {
+                        $$ = new StatementNode( build_with( $3, $5 ) );
+                }
         ;
 
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
-        MUTEX '(' argument_expression_list ')' statement
+        MUTEX '(' argument_expression_list_opt ')' statement
                 { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
         ;
@@ -2489 +2475 @@
 designation:
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
-        | identifier_at ':'                                                                     // GCC, field name
+        | identifier ':'                                                                        // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
         ;
@@ -2501 +2487 @@
 
 designator:
-        '.' identifier_at                                                                       // C99, field name
+        '.' identifier                                                                          // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
@@ -2933 +2919 @@
 
 paren_identifier:
-        identifier_at
+        identifier
                 { $$ = DeclarationNode::newName( $1 ); }
         | '(' paren_identifier ')'                                                      // redundant parenthesis

src/main.cc

@@ -9 +9 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct 22 16:06:00 2021
-// Update Count     : 653
+// Last Modified By : Henry Xue
+// Last Modified On : Mon Aug 23 15:42:08 2021
+// Update Count     : 650
 //
 
@@ -43 +43 @@
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/CompilerError.h"           // for CompilerError
-#include "Common/DeclStats.hpp"             // for printDeclStats
-#include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"
 #include "Common/PassVisitor.h"
@@ -336 +334 @@
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
+
+                if ( libcfap ) {
+                        // generate the bodies of cfa library functions
+                        LibCfa::makeLibCfa( translationUnit );
+                } // if
+
+                if ( declstatsp ) {
+                        CodeTools::printDeclStats( translationUnit );
+                        deleteAll( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+
+                if ( bresolvep ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
 
                 CodeTools::fillLocations( translationUnit );
+
+                if ( resolvprotop ) {
+                        CodeTools::dumpAsResolvProto( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
 
                 if( useNewAST ) {
@@ -346 +366 @@
                         auto transUnit = convert( move( translationUnit ) );
 
-                        forceFillCodeLocations( transUnit );
-
-                        PASS( "Gen Init", InitTweak::genInit( transUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
-
-                        if ( libcfap ) {
-                                // Generate the bodies of cfa library functions.
-                                LibCfa::makeLibCfa( transUnit );
-                        } // if
-
-                        if ( declstatsp ) {
-                                printDeclStats( transUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( bresolvep ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( resolvprotop ) {
-                                dumpAsResolverProto( transUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
+                        
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
@@ -380 +377 @@
 
                         PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
-
                         translationUnit = convert( move( transUnit ) );
                 } else {
-                        PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
-
-                        if ( libcfap ) {
-                                // Generate the bodies of cfa library functions.
-                                LibCfa::makeLibCfa( translationUnit );
-                        } // if
-
-                        if ( declstatsp ) {
-                                CodeTools::printDeclStats( translationUnit );
-                                deleteAll( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( bresolvep ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        CodeTools::fillLocations( translationUnit );
-
-                        if ( resolvprotop ) {
-                                CodeTools::dumpAsResolvProto( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
 
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );

tests/concurrent/semaphore.cfa

@@ -2 +2 @@
 #include <locks.hfa>
 #include <thread.hfa>
-#include <mutex_stmt.hfa>
 
 enum { num_blockers = 17, num_unblockers = 13 };
@@ -29 +28 @@
                 thrash();
                 P(ben);
-                if(((thread&)this).seqable.next != 0p) mutex(sout) sout | "Link not invalidated";
+                if(((thread&)this).seqable.next != 0p) sout | acquire |"Link not invalidated";
                 thrash();
         }

tests/concurrent/sleep.cfa

@@ -1 +1 @@
 #include <fstream.hfa>
 #include <thread.hfa>
-#include <mutex_stmt.hfa>
 #include <time.hfa>
 
@@ -30 +29 @@
 
 int main() {
-        mutex( sout ) sout | "start";
+        sout | acquire | "start";
         {
                 slow_sleeper slow;
@@ -37 +36 @@
                 yield();
         }
-        mutex( sout ) sout | "done";
+        sout | acquire | "done";
 }
 

tests/io/io-acquire.cfa

@@ -10 +10 @@
 // Created On       : Mon Mar  1 18:40:09 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Oct  6 18:04:58 2021
-// Update Count     : 72
+// Last Modified On : Tue Apr 27 11:49:34 2021
+// Update Count     : 18
 // 
 
 #include <fstream.hfa>
 #include <thread.hfa>
-#include <mutex_stmt.hfa>
 
 thread T {};
@@ -22 +21 @@
         // output from parallel threads should not be scrambled
 
-        for ( 100 ) {                                                                           // expression protection
-                mutex(sout) sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+        for ( 100 ) {                                                                           // local protection
+                sout | acquire | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
         }
-        mutex( sout ) {                                                                         // statement protection
+        {                                                                                                       // global protection (RAII)
+                osacquire acq = { sout };
                 for ( 100 ) {
                         sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
@@ -31 +31 @@
         }
         {                                                                                                       // duplicate protection demonstrating recursive lock
-                ofstream & h1( ofstream & os ) {                                // helper
-                        mutex( os ) return os | 1 | 2 | 3 | 4;          // unnecessary mutex
-                }
-                ofstream & h2( ofstream & os ) {                                // helper
-                        mutex( os ) return os | 6 | 7 | 8 | 9;          // unnecessary mutex
-                }
-                mutex( sout ) {                                                                 // unnecessary mutex
-                        for ( 100 ) {
-                                mutex( sout ) {
-                                        sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
-                                        sout | h1 | 5 | h2;                                     // refactored code
-                                }
-                        }
+                osacquire acq = { sout };
+                for ( 100 ) {
+                        osacquire acq = { sout };
+                        sout | acquire | 1 | 2 | 3 | 4 | 5 | acquire | 6 | 7 | 8 | 9;
+                        sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
                 }
         }
@@ -50 +42 @@
 
         int a, b, c, d, e, f, g, h, i;
-        for ( 100 ) {                                                                           // expression protection
-                mutex(sin) sin | a | b | c | d | e | f | g | h | i;
+        for ( 100 ) {                                                                           // local protection
+                sin | acquire | a | b | c | d | e | f | g | h | i;
         }
-        mutex( sin ) {                                                                          // statement protection
+        {                                                                                                       // global protection (RAII)
+                isacquire acq = { sin };
                 for ( 100 ) {
                         sin  | a | b | c | d | e | f | g | h | i;
@@ -59 +52 @@
         }
         {                                                                                                       // duplicate protection demonstrating recursive lock
-                ifstream & h1( ifstream & is ) {                                // helper
-                        mutex( is ) return is | a | b | c | d;          // unnecessary mutex
-                }
-                ifstream & h2( ifstream & is ) {                                // helper
-                        mutex( is ) return is | f | g | h | i;          // unnecessary mutex
-                }
-                mutex( sin ) {                                                                  // unnecessary mutex
-                        for ( 5 ) {
-                                mutex( sin ) {
-                                        sin  | a | b | c | d | e | f | g | h | i;
-                                        sin  | h1 | e | h2;                                     // refactored code
-                                }
-                        }
+                isacquire acq = { sin };
+                for ( 100 ) {
+                        isacquire acq = { sin };
+                        sin | acquire | a | b | c | d | e | acquire | f | g | h | i;
+                        sin | a | b | c | d | e | f | g | h | i;
                 }
         }

tests/linking/io-acquire.cfa

@@ -17 +17 @@
 #include <fstream.hfa>
 #include <stdlib.hfa>
-#include <mutex_stmt.hfa>
 
 int main() {
         int i;
         if(threading_enabled()) {
-                mutex( stdout ) stdout | "YES";
+                stdout | acquire | "YES";
                 stdin | i;
         } else {
-                mutex( stdout ) stdout | "NO";
+                stdout | acquire | "NO";
                 stdin | i;
         }

tests/pybin/test_run.py

@@ -65 +65 @@
         def toString( cls, retcode, duration ):
                 if settings.generating :
-                        if   retcode == TestResult.SUCCESS:     key = 'pass'; text = "Done   "
-                        elif retcode == TestResult.TIMEOUT:     key = 'time'; text = "TIMEOUT"
-                        else :  key = 'fail';   text = "ERROR code %d" % retcode
+                        if   retcode == TestResult.SUCCESS:     text = "Done   "
+                        elif retcode == TestResult.TIMEOUT:     text = "TIMEOUT"
+                        else :                                          text = "ERROR code %d" % retcode
                 else :
-                        if   retcode == TestResult.SUCCESS:     key = 'pass'; text = "PASSED "
-                        elif retcode == TestResult.TIMEOUT:     key = 'time'; text = "TIMEOUT"
-                        else :  key = 'fail';   text = "FAILED with code %d" % retcode
+                        if   retcode == TestResult.SUCCESS:     text = "PASSED "
+                        elif retcode == TestResult.TIMEOUT:     text = "TIMEOUT"
+                        else :                                          text = "FAILED with code %d" % retcode
 
                 text += "    C%s - R%s" % (fmtDur(duration[0]), fmtDur(duration[1]))
-                return key, text
+                return text

tests/test.py

@@ -257 +257 @@
 
                 # update output based on current action
-                result_key, result_txt = TestResult.toString( retcode, duration )
+                result_txt = TestResult.toString( retcode, duration )
 
                 #print result with error if needed
@@ -265 +265 @@
                         text = text + '\n' + error
 
-                return retcode == TestResult.SUCCESS, result_key, text
+                return retcode == TestResult.SUCCESS, text
         except KeyboardInterrupt:
-                return False, 'keybrd', ""
+                return False, ""
         # except Exception as ex:
         #       print("Unexpected error in worker thread running {}: {}".format(t.target(), ex), file=sys.stderr)
@@ -283 +283 @@
 
         failed = False
-        rescnts = {     'pass': 0, 'fail': 0, 'time': 0, 'keybrd': 0 }
-        other = 0
 
         # for each test to run
@@ -296 +294 @@
                 )
 
-                for i, (succ, code, txt) in enumerate(timed(results, timeout = settings.timeout.total), 1) :
-                        if code in rescnts.keys():
-                                rescnts[code] += 1
-                        else:
-                                other += 1
-
+                for i, (succ, txt) in enumerate(timed(results, timeout = settings.timeout.total), 1) :
                         if not succ :
                                 failed = True
@@ -326 +319 @@
         # clean the workspace
         make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
-
-        print("{} passes, {} failures, {} timeouts, {} cancelled, {} other".format(rescnts['pass'], rescnts['fail'], rescnts['time'], rescnts['keybrd'], other))
 
         return failed
@@ -452 +443 @@
                         failed = run_tests(local_tests, options.jobs)
                         if failed:
+                                result = 1
                                 if not settings.continue_:
                                         break