Changeset f45772e

Timestamp:

Oct 8, 2023, 9:14:31 AM (12 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

92211d9

Parents:

2261bcc (diff), 9689e54 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

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

Files:

• Jenkins/FullBuild (modified) (1 diff)
• Jenkins/TestRegen (modified) (1 diff)
• libcfa/src/collections/string_res.cfa (modified) (3 diffs)
• libcfa/src/iostream.cfa (modified) (5 diffs)
• src/CodeGen/LinkOnce.cc (modified) (5 diffs)
• src/CodeGen/LinkOnce.h (modified) (2 diffs)
• src/GenPoly/BoxNew.cpp (modified) (25 diffs)
• src/GenPoly/InstantiateGeneric.h (modified) (2 diffs)
• src/GenPoly/InstantiateGenericNew.cpp (modified) (1 diff)
• src/Validate/NoIdSymbolTable.hpp (modified) (1 diff)
• src/main.cc (modified) (1 diff)
• tests/collections/.expect/string-istream-manip.txt (modified) (3 diffs)
• tests/collections/.in/string-istream-manip.txt (modified) (1 diff)
• tests/collections/string-istream-manip.cfa (modified) (3 diffs)
• tests/errors/.expect/scope-type.txt (added)
• tests/errors/.expect/scope.txt (modified) (1 diff)
• tests/errors/scope-type.cfa (added)
• tests/errors/scope.cfa (modified) (1 diff)
• tests/io/.expect/manipulatorsInput.arm64.txt (modified) (3 diffs)
• tests/io/.expect/manipulatorsInput.x64.txt (modified) (3 diffs)
• tests/io/.expect/manipulatorsInput.x86.txt (modified) (3 diffs)
• tests/io/.in/manipulatorsInput.txt (modified) (1 diff)
• tests/io/manipulatorsInput.cfa (modified) (3 diffs)
• tests/test.py (modified) (1 diff)
• tools/build/cfa.m4 (modified) (1 diff)

Jenkins/FullBuild

@@ -25 +25 @@
                                         gcc_08_x64_new: { trigger_build( 'gcc-8',   'x64', false ) },
                                         gcc_07_x64_new: { trigger_build( 'gcc-7',   'x64', false ) },
-                                        // gcc_06_x64_new: { trigger_build( 'gcc-6',   'x64', false ) },
+                                        gcc_11_arm64_new: { trigger_build( 'gcc-11',  'arm64', false ) },
+                                        gcc_10_arm64_new: { trigger_build( 'gcc-10',  'arm64', false ) },
+                                        gcc_09_arm64_new: { trigger_build( 'gcc-9',   'arm64', false ) },
+                                        // gcc_06_arm64_new: { trigger_build( 'gcc-6',   'arm64', false ) },
                                         clang_x64_new:  { trigger_build( 'clang',   'x64', true  ) },
                                 )

Jenkins/TestRegen

@@ -24 +24 @@
                 stage('Building x64') {
                         regen_tests('x86_64')
+                }
+
+                stage('Building arm64') {
+                        regen_tests('arm64')
                 }
 

libcfa/src/collections/string_res.cfa

@@ -218 +218 @@
     // Read in chunks.  Often, one chunk is enough.  Keep the string that accumulates chunks last in the heap,
     // so available room is rest of heap.  When a chunk fills the heap, force growth then take the next chunk.
-    for (;;) {
+    for (bool cont = true; cont; ) {
+        cont = false;
+
         // Append dummy content to temp, forcing expansion when applicable (occurs always on subsequent loops)
         // length 2 ensures room for at least one real char, plus scanf/pipe-cstr's null terminator
@@ -228 +230 @@
         temp.Handle.ulink->EndVbyte -= 2;
 
-        // rest of heap, less 1 byte for null terminator, is available to read into
-        int lenReadable = (char*)temp.Handle.ulink->ExtVbyte - temp.Handle.ulink->EndVbyte - 1;
-        assert (lenReadable >= 1);
+        // rest of heap is available to read into
+        int lenReadable = (char*)temp.Handle.ulink->ExtVbyte - temp.Handle.ulink->EndVbyte;
+        assert (lenReadable >= 2);
 
         // get bytes
-        in | wdi( lenReadable + 1, lenReadable, temp.Handle.ulink->EndVbyte );
+        try {
+            in | wdi( lenReadable, temp.Handle.ulink->EndVbyte );
+        } catch (cstring_length*) {
+            cont = true;
+        }
         int lenWasRead = strlen(temp.Handle.ulink->EndVbyte);
 
@@ -239 +245 @@
         temp.Handle.lnth += lenWasRead;
         temp.Handle.ulink->EndVbyte += lenWasRead;
-
-      if (lenWasRead < lenReadable) break;
     }
 

libcfa/src/iostream.cfa

@@ -22 +22 @@
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
+#include <ctype.h>                                                                              // isspace
 //#include <stdio.h>
 
@@ -29 +30 @@
 extern char *strcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
 extern void *memcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *strchr(const char *str, int ch);
 } // extern "C"
 
@@ -960 +962 @@
         istype & ?|?( istype & is, _Istream_Cskip f ) {
                 // printf( "skip %s %d\n", f.scanset, f.wd );
-                if ( f.scanset ) fmt( is, f.scanset, "" );              // no input arguments
+                if ( f.scanset ) {
+                        int nscanset = strlen(f.scanset);
+                        char fmtstr[ sizeof("%*[]") + nscanset ];
+                        int pos = 0;
+                        fmtstr[pos] = '%';                  pos += 1;
+                        fmtstr[pos] = '*';                  pos += 1;
+                        fmtstr[pos] = '[';                  pos += 1;
+                        strcpy( &fmtstr[pos], f.scanset );  pos += nscanset;
+                        fmtstr[pos] = ']';                  pos += 1;
+                        fmtstr[pos] = '\0';
+                        fmt( is, fmtstr, (void*)0 );  // last arg is dummy: suppress gcc warning
+                }
                 else for ( f.wd ) fmt( is, "%*c" );
                 return is;
@@ -980 +993 @@
                         // wd is buffer bytes available (for input chars + null terminator)
                         // rwd is count of input chars
-                        int rwd = f.flags.rwd ? f.wd : (f.wd - 1);
+                        int rwd;
+                        if (f.flags.rwd) {
+                                verify (f.wd >= 0);
+                                rwd = f.wd;
+                        } else {
+                                verify (f.wd >= 1);
+                                rwd = f.wd - 1;
+                        } // if
                         start += sprintf( &fmtstr[start], "%d", rwd );
                 }
@@ -1000 +1020 @@
 
                 int check = f.wd - 2;
-                if ( ! f.flags.rwd ) f.s[check] = '\0';                 // insert sentinel
+                if (! f.flags.ignore ) {
+                        f.s[0] = '\0';
+                        if ( ! f.flags.rwd ) f.s[check] = '\0';         // insert sentinel
+                }
                 len = fmt( is, fmtstr, f.s );
                 //fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, f.s[check], f.s );
 
-                if ( ! f.flags.rwd && f.s[check] != '\0' )              // sentinel overwritten ?
-                        throw (cstring_length){ &cstring_length_vt };
+                if ( ! f.flags.ignore && ! f.flags.rwd && f.s[check] != '\0' ) { // sentinel overwritten ?
+                        // buffer filled, but would we have kept going?
+                        if ( ! eof( is ) ) {
+                                char peek;
+                                fmt( is, "%c", &peek );
+                                ungetc( is, peek );
+                                bool hasMore;
+                                if (f.flags.delimiter) { // getline
+                                        hasMore = (peek != f.delimiter[0]);
+                                } else if (f.scanset) { // incl/excl
+                                        bool peekMatch = strchr(f.scanset, peek) != 0p;
+                                        hasMore = f.flags.inex ? (!peekMatch) : (peekMatch);
+                                } else { // %s
+                                        hasMore = !isspace(peek);
+                                }
+                                if (hasMore) throw (cstring_length){ &cstring_length_vt };
+                        } // if
+                } // if
 
                 if ( f.flags.delimiter ) {                                              // getline ?

src/CodeGen/LinkOnce.cc

@@ -10 +10 @@
 // Created On       : Thur May 13 10:10:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Thur May 13 14:39:00 2021
-// Update Count     : 0
+// Last Modified On : Wed Oct  4 10:52:00 2023
+// Update Count     : 1
 //
 
@@ -18 +18 @@
 #include <algorithm>
 
+#include "AST/Attribute.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Pass.hpp"
 #include "Common/PassVisitor.h"       // for PassVisitor, WithShortCircuiting
 
 namespace CodeGen {
 
-static bool is_cfa_linkonce( Attribute const * attr ) {
+namespace {
+
+bool is_cfa_linkonce_old( Attribute const * attr ) {
         return std::string("cfa_linkonce") == attr->name;
 }
 
-static bool is_section_attribute( Attribute const * attr ) {
+bool is_section_attribute_old( Attribute const * attr ) {
         return std::string("section") == attr->name;
 }
@@ -39 +45 @@
                 std::list< Attribute * > & attributes = decl->attributes;
                 // See if we can find the element:
-                auto found = std::find_if(attributes.begin(), attributes.end(), is_cfa_linkonce );
+                auto found = std::find_if(attributes.begin(), attributes.end(), is_cfa_linkonce_old );
                 if ( attributes.end() != found ) {
                         // Remove any other sections:
-                        attributes.remove_if( is_section_attribute );
+                        attributes.remove_if( is_section_attribute_old );
                         // Iterator to the cfa_linkonce attribute should still be valid.
                         Attribute * attribute = *found;
@@ -63 +69 @@
 };
 
+bool is_cfa_linkonce( ast::Attribute const * attr ) {
+        return "cfa_linkonce" == attr->name;
+}
+
+bool is_section_attribute( ast::Attribute const * attr ) {
+        return "section" == attr->name;
+}
+
+struct LinkOnceCore : public ast::WithShortCircuiting {
+        void previsit( ast::Decl const * ) {
+                visit_children = false;
+        }
+
+        ast::DeclWithType const * postvisit( ast::DeclWithType const * decl ) {
+                // Check to see if we have to mutate, because should be uncommon.
+                {
+                        auto & attributes = decl->attributes;
+                        auto found = std::find_if( attributes.begin(), attributes.end(),
+                                        is_cfa_linkonce );
+                        if ( attributes.end() == found ) return decl;
+                }
+                auto mutDecl = mutate( decl );
+                auto & attributes = mutDecl->attributes;
+
+                // Remove all conflicting section attributes.
+                erase_if( attributes, is_section_attribute );
+
+                // Get the attribute, and overwrite it as a section attribute.
+                auto found = std::find_if( attributes.begin(), attributes.end(),
+                                is_cfa_linkonce );
+                assert( attributes.end() != found );
+                ast::Attribute * attribute = found->get_and_mutate();
+                assert( attribute->params.empty() );
+                assert( !decl->mangleName.empty() );
+
+                attribute->name = "section";
+                attribute->params.push_back(
+                        ast::ConstantExpr::from_string( mutDecl->location,
+                                ".gnu.linkonce." + decl->mangleName
+                        )
+                );
+
+                // Unconditionnaly add "visibility(default)" to anything with
+                // .gnu.linkonce visibility is a mess otherwise.
+                attributes.push_back( new ast::Attribute( "visibility", {
+                        ast::ConstantExpr::from_string( mutDecl->location, "default" )
+                } ) );
+                return mutDecl;
+        }
+};
+
+} // namespace
+
 void translateLinkOnce( std::list< Declaration *> & translationUnit ) {
         PassVisitor<LinkOnceVisitorCore> translator;
@@ -68 +127 @@
 }
 
+void translateLinkOnce( ast::TranslationUnit & translationUnit ) {
+        ast::Pass<LinkOnceCore>::run( translationUnit );
 }
+
+} // namespace CodeGen

src/CodeGen/LinkOnce.h

@@ -10 +10 @@
 // Created On       : Thur May 13 10:06:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Thur May 13 14:38:00 2021
-// Update Count     : 0
+// Last Modified On : Wed Oct  4 10:52:00 2023
+// Update Count     : 1
 //
 
@@ -23 +23 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace CodeGen {
 
 void translateLinkOnce( std::list< Declaration *> & translationUnit );
+void translateLinkOnce( ast::TranslationUnit & translationUnit );
 /* Convert the cfa_linkonce attribute on top level declaration into
  * a special section declaration (.gnu.linkonce) so that it may be defined

src/GenPoly/BoxNew.cpp

@@ -77 +77 @@
 };
 
-// Formally takeOtypeOnly
 /// Get all sized type declarations; those that affect a layout function.
 ast::vector<ast::TypeDecl> takeSizedParams(
@@ -510 +509 @@
                 ast::FunctionType const * function,
                 TypeVarMap const & typeVars ) {
-        // TODO
-        // NOTE: This function previously used isPolyObj, which failed to produce
-        // the correct thing in some situations. It's not clear to [Rob Schluntz]
-        // why this wasn't working.
-
         // If the return type or a parameter type involved polymorphic types,
         // then the adapter will need to take those polymorphic types as pointers.
@@ -587 +581 @@
         ast::FunctionType const * type = decl->type;
         if ( isDynRet( type ) && decl->linkage != ast::Linkage::C ) {
-                //retval = type->returns.front();
                 retval = decl->returns.front();
 
@@ -748 +741 @@
 ast::Expr const * CallAdapter::postvisit( ast::UntypedExpr const * expr ) {
         if ( isPolyDeref( expr, scopeTypeVars, typeSubs ) ) {
-                // TODO Pretty sure this is just a memory management change.
-                // Also, I don't understand what this is doing.
-                //ast::Expr const * ret = expr->args.front();
-                //expr->args.clear();
-                //return ret;
                 return expr->args.front();
         }
@@ -1063 +1051 @@
                 ast::ptr<ast::Type> newType = ast::deepCopy( param );
                 if ( typeSubs ) typeSubs->apply( newType );
-                // TODO: Is this right? (Why wouldn't it be?)
-                // I think this is to make sure we can write to the temporary.
-                //newType.get_and_mutate()->qt = ast::CV::Qualifiers();
-                //reset_qualifiers( newType );
                 ast::ObjectDecl * newObj = makeTemporary( location, newType );
                 auto assign = ast::UntypedExpr::createCall( location, "?=?", {
@@ -1245 +1229 @@
                         }
                         return new ast::ObjectDecl( location, pNamer.newName(), param );
-                } ), // params
+                } ),
                 map_range<ast::vector<ast::DeclWithType>>( adapterType->returns,
                                 [&rNamer, &location]( ast::ptr<ast::Type> const & retval ) {
                         return new ast::ObjectDecl( location, rNamer.newName(), retval );
-                } ), // returns
+                } ),
                 nullptr, // stmts
-                ast::Storage::Classes(), // storage
-                ast::Linkage::C // linkage
-                // attrs
-                // fs
-                // isVarArgs
+                {}, // storage
+                ast::Linkage::C
         );
 
@@ -1314 +1295 @@
         // Returns a polymorphic type.
         } else if ( isDynType( adaptee->returns.front(), typeVars ) ) {
-                if ( "" == (*paramDecl)->name ) {
-                        // TODO: Is it easier to make sure it has a name in the first
-                        // place? - I believe this is done, however, I could remove the
-                        // condition and just rename for clarity.
-                        assertf( false, "Wasn't expecting to get here." );
-                        auto mutParam = paramDecl->get_and_mutate();
-                        mutParam->name = "_ret";
-                        mutParam->linkage = ast::Linkage::C;
-                }
                 ast::UntypedExpr * assign = new ast::UntypedExpr( location,
                         new ast::NameExpr( location, "?=?" ) );
@@ -1546 +1518 @@
 
 // --------------------------------------------------------------------------
-/// Creates the adapter functions. TODO
+/// Modifies declarations to accept implicit parameters.
 /// * Move polymorphic returns in function types to pointer-type parameters.
 /// * Adds type size and assertion parameters to parameter lists.
-struct DeclAdapter final :
-                public BoxPass,
-                public ast::WithGuards {
-        void handleAggrDecl();
-
-        void previsit( ast::StructDecl const * decl );
-        void previsit( ast::UnionDecl const * decl );
-        void previsit( ast::TraitDecl const * decl );
-        void previsit( ast::TypeDecl const * decl );
-        void previsit( ast::PointerType const * type );
-        void previsit( ast::FunctionType const * type );
+struct DeclAdapter final {
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
-        ast::DeclWithType const * postvisit( ast::FunctionDecl const * decl );
-        void previsit( ast::CompoundStmt const * stmt );
+        ast::FunctionDecl const * postvisit( ast::FunctionDecl const * decl );
 private:
-        ast::FunctionDecl * addAdapters( ast::FunctionDecl * decl );
-
-        std::map<UniqueId, std::string> adapterName;
+        void addAdapters( ast::FunctionDecl * decl, TypeVarMap & localTypeVars );
 };
 
-// at must point within [dst.begin(), dst.end()].
-template< typename T >
-void spliceAt( std::vector< T > & dst, typename std::vector< T >::iterator at,
-                std::vector< T > & src ) {
-        std::vector< T > tmp;
-        tmp.reserve( dst.size() + src.size() );
-        typename std::vector< T >::iterator it = dst.begin();
-        while ( it != at ) {
-                assert( it != dst.end() );
-                tmp.emplace_back( std::move( *it ) );
-                ++it;
-        }
-        for ( T & x : src ) { tmp.emplace_back( std::move( x ) ); }
-        while ( it != dst.end() ) {
-                tmp.emplace_back( std::move( *it ) );
-                ++it;
-        }
-
-        dst.clear();
-        src.clear();
-        tmp.swap( dst );
-}
-
-void DeclAdapter::previsit( ast::StructDecl const * ) {
-        // Prevent type vars from leaking into the containing scope.
-        GuardScope( scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::UnionDecl const * ) {
-        // Prevent type vars from leaking into the containing scope.
-        GuardScope( scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::TraitDecl const * ) {
-        // Prevent type vars from leaking into the containing scope.
-        GuardScope( scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::TypeDecl const * decl ) {
-        addToTypeVarMap( decl, scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::PointerType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
-}
-
-// TODO: I think this code is redundent.
-void DeclAdapter::previsit( ast::FunctionType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+// size/align/offset parameters may not be used, so add the unused attribute.
+ast::ObjectDecl * makeObj(
+                CodeLocation const & location, std::string const & name ) {
+        return new ast::ObjectDecl( location, name,
+                makeSizeAlignType(),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
+                { new ast::Attribute( "unused" ) } );
+}
+
+ast::ObjectDecl * makePtr(
+                CodeLocation const & location, std::string const & name ) {
+        return new ast::ObjectDecl( location, name,
+                new ast::PointerType( makeSizeAlignType() ),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
 }
 
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( decl, scopeTypeVars );
+        TypeVarMap localTypeVars = { ast::TypeData() };
+        makeTypeVarMap( decl, localTypeVars );
 
         auto mutDecl = mutate( decl );
@@ -1639 +1561 @@
 
         // Add size/align and assertions for type parameters to parameter list.
-        std::vector<ast::ptr<ast::DeclWithType>>::iterator last = mutDecl->params.begin();
-        std::vector<ast::ptr<ast::DeclWithType>> inferredParams;
-        // size/align/offset parameters may not be used in body, pass along with unused attribute.
-        // TODO: These should be created with proper location and name.
-        // TODO: makeSizeAlign[Out]Type are the same as these types, but they may
-        // be logically different.
-        ast::ObjectDecl newObj( mutDecl->location, "",
-                new ast::BasicType( ast::BasicType::LongUnsignedInt ),
-                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
-                { new ast::Attribute( "unused" ) } );
-        ast::ObjectDecl newPtr( mutDecl->location, "",
-                new ast::PointerType( new ast::BasicType( ast::BasicType::LongUnsignedInt ) ),
-                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
+        ast::vector<ast::DeclWithType> inferredParams;
+        ast::vector<ast::DeclWithType> layoutParams;
         for ( ast::ptr<ast::TypeDecl> & typeParam : mutDecl->type_params ) {
                 auto mutParam = mutate( typeParam.get() );
                 // Add all size and alignment parameters to parameter list.
                 if ( mutParam->isComplete() ) {
-                        //ast::TypeInstType paramType( typeParam->name, typeParam );
                         ast::TypeInstType paramType( mutParam );
                         std::string paramName = Mangle::mangleType( &paramType );
 
-                        ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj );
-                        sizeParam->location = typeParam->location;
-                        sizeParam->name = sizeofName( paramName );
-                        last = mutDecl->params.insert( last, sizeParam );
-                        ++last;
-
-                        ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
-                        alignParam->location = typeParam->location;
-                        alignParam->name = alignofName( paramName );
-                        last = mutDecl->params.insert( last, alignParam );
-                        ++last;
+                        auto sizeParam = makeObj( typeParam->location, sizeofName( paramName ) );
+                        layoutParams.emplace_back( sizeParam );
+
+                        auto alignParam = makeObj( typeParam->location, alignofName( paramName ) );
+                        layoutParams.emplace_back( alignParam );
                 }
                 // TODO: These should possibly all be gone.
@@ -1696 +1600 @@
         // Add size/align for generic parameter types to parameter list.
         std::set<std::string> seenTypes;
-        std::vector<ast::ptr<ast::DeclWithType>> otypeParams;
+        ast::vector<ast::DeclWithType> otypeParams;
         for ( ast::ptr<ast::DeclWithType> & funcParam : mutDecl->params ) {
-                ast::Type const * polyType = isPolyType( funcParam->get_type(), scopeTypeVars );
+                ast::Type const * polyType = isPolyType( funcParam->get_type(), localTypeVars );
                 if ( !polyType || dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
                         continue;
@@ -1704 +1608 @@
                 std::string typeName = Mangle::mangleType( polyType );
                 if ( seenTypes.count( typeName ) ) continue;
-
-                ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj );
-                sizeParam->location = funcParam->location;
-                sizeParam->name = sizeofName( typeName );
+                seenTypes.insert( typeName );
+
+                auto sizeParam = makeObj( funcParam->location, sizeofName( typeName ) );
                 otypeParams.emplace_back( sizeParam );
 
-                ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
-                alignParam->location = funcParam->location;
-                alignParam->name = alignofName( typeName );
+                auto alignParam = makeObj( funcParam->location, alignofName( typeName ) );
                 otypeParams.emplace_back( alignParam );
 
+                // Zero-length arrays are illegal in C, so empty structs have no
+                // offset array.
                 if ( auto * polyStruct =
-                                dynamic_cast<ast::StructInstType const *>( polyType ) ) {
-                        // Zero-length arrays are illegal in C, so empty structs have no
-                        // offset array.
-                        if ( !polyStruct->base->members.empty() ) {
-                                ast::ObjectDecl * offsetParam = ast::deepCopy( &newPtr );
-                                offsetParam->location = funcParam->location;
-                                offsetParam->name = offsetofName( typeName );
-                                otypeParams.emplace_back( offsetParam );
-                        }
-                }
-                seenTypes.insert( typeName );
-        }
-
-        // TODO: A unified way of putting these together might be nice.
-        // Put the list together: adapters (in helper) otype parameters,
-        // inferred params., layout params. (done) and finally explicit params.
-        spliceBegin( inferredParams, otypeParams );
-        spliceAt( mutDecl->params, last, inferredParams );
-        mutDecl = addAdapters( mutDecl );
+                                dynamic_cast<ast::StructInstType const *>( polyType ) ;
+                                polyStruct && !polyStruct->base->members.empty() ) {
+                        auto offsetParam = makePtr( funcParam->location, offsetofName( typeName ) );
+                        otypeParams.emplace_back( offsetParam );
+                }
+        }
+
+        // Prepend each argument group. From last group to first. addAdapters
+        // does do the same, it just does it itself and see all other parameters.
+        spliceBegin( mutDecl->params, inferredParams );
+        spliceBegin( mutDecl->params, otypeParams );
+        spliceBegin( mutDecl->params, layoutParams );
+        addAdapters( mutDecl, localTypeVars );
 
         return mutDecl;
 }
 
-ast::DeclWithType const * DeclAdapter::postvisit(
+ast::FunctionDecl const * DeclAdapter::postvisit(
                 ast::FunctionDecl const * decl ) {
         ast::FunctionDecl * mutDecl = mutate( decl );
@@ -1773 +1670 @@
 }
 
-void DeclAdapter::previsit( ast::CompoundStmt const * ) {
-        GuardScope( scopeTypeVars );
-        // TODO: It is entirely possible the scope doesn't need to spread
-        // across multiple functions. Otherwise, find a better clear.
-        std::set<TypeVarMap::key_type> keys;
-        for ( auto pair : const_cast<TypeVarMap const &>( scopeTypeVars ) ) {
-                keys.insert( pair.first );
-        }
-        for ( auto key : keys ) {
-                scopeTypeVars.erase( key );
-        }
-}
-
-// It actually does mutate in-place, but does the return for consistency.
-ast::FunctionDecl * DeclAdapter::addAdapters( ast::FunctionDecl * mutDecl ) {
-        std::vector<ast::ptr<ast::FunctionType>> functions;
+void DeclAdapter::addAdapters(
+                ast::FunctionDecl * mutDecl, TypeVarMap & localTypeVars ) {
+        ast::vector<ast::FunctionType> functions;
         for ( ast::ptr<ast::DeclWithType> & arg : mutDecl->params ) {
                 ast::Type const * type = arg->get_type();
-                type = findAndReplaceFunction( type, functions, scopeTypeVars, needsAdapter );
+                type = findAndReplaceFunction( type, functions, localTypeVars, needsAdapter );
                 arg.get_and_mutate()->set_type( type );
         }
         std::set<std::string> adaptersDone;
         for ( ast::ptr<ast::FunctionType> const & func : functions ) {
-                std::string mangleName = mangleAdapterName( func, scopeTypeVars );
+                std::string mangleName = mangleAdapterName( func, localTypeVars );
                 if ( adaptersDone.find( mangleName ) != adaptersDone.end() ) {
                         continue;
@@ -1804 +1688 @@
                 mutDecl->params.insert( mutDecl->params.begin(), new ast::ObjectDecl(
                         mutDecl->location, adapterName,
-                        new ast::PointerType( makeAdapterType( func, scopeTypeVars ) ),
+                        new ast::PointerType( makeAdapterType( func, localTypeVars ) ),
                         nullptr, {}, {}, nullptr,
                         { new ast::Attribute( "unused" ) } ) );
                 adaptersDone.insert( adaptersDone.begin(), mangleName );
         }
-        return mutDecl;
 }
 
@@ -1926 +1809 @@
         /// Namer for VLA (variable length array) buffers.
         UniqueName bufNamer;
-        /// AddressExpr argument is MemberExpr? (TODO: What?)
-        ast::Expr const * addrMember = nullptr;
+        /// If the argument of an AddressExpr is MemberExpr, it is stored here.
+        ast::MemberExpr const * addrMember = nullptr;
         /// Used to avoid recursing too deep in type declarations.
         bool expect_func_type = false;
@@ -1959 +1842 @@
         beginTypeScope( decl->type );
 
-        // - Tried inserting this code.
-        // Make sure that any type information passed into the function is
-        // accounted for.
-        // TODO: For some reason going through decl->params/->get_type() does
-        // not work. Possibly something is not getting updated.
+        // TODO: Going though dec->params does not work for some reason.
         for ( ast::ptr<ast::Type> const & funcParam : decl->type->params ) {
                 // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )`
@@ -2019 +1898 @@
 ast::StructDecl const * PolyGenericCalculator::previsit(
                 ast::StructDecl const * decl ) {
-        //return strict_dynamic_cast<ast::StructDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -2027 +1905 @@
 ast::UnionDecl const * PolyGenericCalculator::previsit(
                 ast::UnionDecl const * decl ) {
-        //return strict_dynamic_cast<ast::UnionDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -2088 +1965 @@
         auto mutDecl = mutate( decl );
 
-        //mutDecl->attributes.remove_if( matchAndMove );
-        // TODO: This common helper might work, but does not officially support
-        // side effects.
+        // Forally, side effects are not safe in this function. But it works.
         erase_if( mutDecl->attributes, matchAndMove );
 
@@ -2198 +2073 @@
         // the substitution manually. For some reason this is not currently the
         // case. This requires more investigation.
-        ast::Type const * memberType = deepCopy( expr->member->get_type() );
+        ast::ptr<ast::Type> memberType = deepCopy( expr->member->get_type() );
         ast::TypeSubstitution sub = genericSubstitution( objectType );
-        auto result = sub.apply( memberType );
-        memberType = result.node.get(); // .release();
+        sub.apply( memberType );
+
         // Not all members of a polymorphic type are themselves of a polymorphic
         // type; in this cas the member expression should be wrapped and
@@ -2217 +2092 @@
 
 void PolyGenericCalculator::previsit( ast::AddressExpr const * expr ) {
-        // Is the argument a MemberExpr before mutating?
         GuardValue( addrMember ) = expr->arg.as<ast::MemberExpr>();
 }
@@ -2233 +2107 @@
         // MemberExpr was converted to pointer + offset; and it is not valid C to
         // take the address of an addition, so stript the address-of.
-        // TODO: should expr->arg->result be changed to expr->result?
-        ast::Expr * ret = mutate( expr->arg.get() );
-        ret->env = expr->env;
-        return ret;
+        // It also preserves the env value.
+        return ast::mutate_field( expr->arg.get(), &ast::Expr::env, expr->env );
 }
 
@@ -2572 +2444 @@
                 public BoxPass,
                 public ast::WithGuards {
-        template<typename decl_t>
-        decl_t const * handleDecl( decl_t const * decl, ast::Type const * type );
+        void guardTypeVarMap( ast::Type const * type ) {
+                GuardScope( scopeTypeVars );
+                makeTypeVarMap( type, scopeTypeVars );
+        }
 
         ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl );
@@ -2585 +2459 @@
 };
 
-template<typename decl_t>
-decl_t const * Eraser::handleDecl(
-                decl_t const * decl, ast::Type const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
+        guardTypeVarMap( decl->type );
         return scrubAllTypeVars( decl );
 }
 
-ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
-        return handleDecl( decl, decl->type );
-}
-
 ast::FunctionDecl const * Eraser::previsit( ast::FunctionDecl const * decl ) {
-        return handleDecl( decl, decl->type );
+        guardTypeVarMap( decl->type );
+        return scrubAllTypeVars( decl );
 }
 
 ast::TypedefDecl const * Eraser::previsit( ast::TypedefDecl const * decl ) {
-        return handleDecl( decl, decl->base );
+        guardTypeVarMap( decl->base );
+        return scrubAllTypeVars( decl );
 }
 
@@ -2608 +2477 @@
 template<typename node_t>
 node_t const * stripGenericMembers( node_t const * decl ) {
-        if ( !decl->params.empty() ) {
-                auto mutDecl = ast::mutate( decl );
-                mutDecl->members.clear();
-                return mutDecl;
-        }
-        return decl;
+        if ( decl->params.empty() ) return decl;
+        auto mutDecl = ast::mutate( decl );
+        mutDecl->members.clear();
+        return mutDecl;
 }
 
@@ -2629 +2496 @@
 
 void Eraser::previsit( ast::PointerType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+        guardTypeVarMap( type );
 }
 
 void Eraser::previsit( ast::FunctionType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+        guardTypeVarMap( type );
 }
 

src/GenPoly/InstantiateGeneric.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// InstantiateGeneric.h --
+// InstantiateGeneric.h -- Create concrete instances of generic types.
 //
 // Author           : Aaron B. Moss
@@ -24 +24 @@
 
 namespace GenPoly {
-/// Replaces all generic types that have static layout with concrete
-/// instantiations. Types with concrete values for otype parameters will be
-/// template-expanded, while dtype and ftype parameters will be replaced by
-/// the appropriate void type.
+
 void instantiateGeneric( std::list< Declaration* > &translationUnit );
 void instantiateGeneric( ast::TranslationUnit & translationUnit );
+/// Replaces all generic types that have static layout with concrete
+/// instantiations. Sized types are replaced with the concrete argument types
+/// while unsized types are erased to a void type.
+/// This pass can cause designators to ignore the pretty print option.
+
 } // namespace GenPoly
 

src/GenPoly/InstantiateGenericNew.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// InstantiateGenericNew.cpp --
+// InstantiateGenericNew.cpp -- Create concrete instances of generic types.
 //
 // Author           : Andrew Beach

src/Validate/NoIdSymbolTable.hpp

@@ -20 +20 @@
 namespace Validate {
 
-// A SymbolTable that only has the operations used in the Translate Dimension
-// pass. More importantly, it doesn't have some methods that should no be
+// A SymbolTable that only tracks names relevant to Validate passes.
+// It tracks type names but not identifier names.
+// Some of the canonicalization that occurs before the resolver
+// affects how identifier name errors get reported to the user.
+// The Validate phase needs to chase type names,
+// but it is too early to try tracking identifier names.
+// Identifier skipping is acheived by omitting methods that should not be
 // called by the Pass template (lookupId and addId).
 class NoIdSymbolTable {
         ast::SymbolTable base;
 public:
+        // All names that are tracked (now) are eligible for collision validation (now).
+        // (Names that are only tracked later get their collision validation then.)
+        NoIdSymbolTable() : base(ast::SymbolTable::ValidateOnAdd) {}
+
 #       define FORWARD_X( func, types_and_names, just_names ) \
         inline auto func types_and_names -> decltype( base.func just_names ) { \

src/main.cc

@@ -421 +421 @@
                 DUMP( bboxp, std::move( transUnit ) );
                 PASS( "Box", GenPoly::box, transUnit );
+                PASS( "Link-Once", CodeGen::translateLinkOnce, transUnit );
 
                 translationUnit = convert( std::move( transUnit ) );
-
-                PASS( "Link-Once", CodeGen::translateLinkOnce, translationUnit );
 
                 // Code has been lowered to C, now we can start generation.

tests/collections/.expect/string-istream-manip.txt

@@ +1 @@
+preS1 0123456
+preS1 x
+preS2 01234567
+preS2 x
+preS3 012345678
+preS3 x
+preS4 0123456789
+preS4 x
+preSMN1 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456
+preSMN1 x
+preSMN2 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567
+preSMN2 x
+preSMN3 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678
+preSMN3 x
+preSMN4 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789
+preSMN4 x
+preRMN1 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456
+preRMN1 x
+preRMN2 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567
+preRMN2 x
+preRMN3 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678
+preRMN3 x
+preRMN4 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789
+preRMN4 x
+preSMI1 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...       "
+preSMI1 "x"
+preSMI2 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...        "
+preSMI2 "x"
+preSMI3 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...         "
+preSMI3 "x"
+preSMI4 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...          "
+preSMI4 "x"
+preSME1 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...       "
+preSME1 "x"
+preSME2 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...        "
+preSME2 "x"
+preSME3 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...         "
+preSME3 "x"
+preSME4 "...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...          "
+preSME4 "x"
+preSMG1 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456
+preSMG1 x
+preSMG2 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567
+preSMG2 x
+preSMG3 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678
+preSMG3 x
+preSMG4 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789
+preSMG4 x
+preSMD1 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456
+preSMD1 x
+preSMD2 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567
+preSMD2 x
+preSMD3 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678
+preSMD3 x
+preSMD4 ...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789
+preSMD4 x
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -12 +68 @@
 12 wwwwwwww
 13 wwwwwwww
+14 cccc
+15 
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -25 +83 @@
 12 wwwwwwww
 13 wwwwwwww
+14 cccc
+15 

tests/collections/.in/string-istream-manip.txt

@@ +1 @@
+0123456 x
+01234567 x
+012345678 x
+0123456789 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789 x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...       -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...        -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...         -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...          -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...       -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...        -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...         -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...          -x-
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456
+x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567
+x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678
+x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789
+x
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456@x@
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...01234567@x@
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...012345678@x@
+...:...:...:...|...:...:...:...|...:...:...:...|...:...:...:...#...:...:...:...|...:...:...:...|...:...:...:...|...:...0123456789@x@
 abc 
-abc 
+cccccb 
 xx
 abcxxx
 abcyyy
 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
+uuuuuccccuuuuu
 abc 
-abc 
+cccccb 
 xx
 abcxxx
 abcyyy
 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
+uuuuuccccuuuuu

tests/collections/string-istream-manip.cfa

@@ -3 +3 @@
 #include <collections/string.hfa>
 #include <collections/string_res.hfa>
+#include <stdio.h>
+
+// No-op manipulators.
+// Temporary hack while there are two code paths in the string implementation.
+// (One for reading plain strings, the other for reading via a manipulator.)
+// The test cases that use plainjane(-) are exercising the via-manipulator code path,
+// just with trivial manipulation.
+static _Istream_Sstr plainjane( string     & s )  { return (_Istream_Sstr)@{  s, {{0p}, -1, {.flags.rwd : false}} }; }
+static _Istream_Rstr plainjane( string_res & s )  { return (_Istream_Rstr)@{ &s, {{0p}, -1, {.flags.rwd : false}} }; }
+
+static void forceStringHeapFreeSpaceTo(int desiredSize) {
+    for (1_000_000) {
+        string x = "a";
+        (void)x;
+      if (desiredSize == DEBUG_string_bytes_avail_until_gc(DEBUG_string_heap())) return;
+    }
+    sout | "Unable to force size" | desiredSize | "in 1,000,000 tries";
+}
 
 int main() {
+    // These "pre" cases deal with issues analogous to the "pre" cases of io/manipulatorsInput.
+    // The acceptance criterion is simpler but driving the cases is harder.
+    // The tests just read strings and echo what they read; acceptance of simple echoing assures
+    // no spurious splitting merging.
+    // The lengths of the strings are chosen to match white-box knowledge of when the string layer
+    // has tor drive the cstring layer through a second iteration:
+    //  - for no-manip, lengths are near the room at end of string heap
+    //    (chosen target size of 9 showed the original bug on preS2, aligned with the other cases)
+    //  - for manip, lengths are near the auxiliary buffer size of 128
+    // Only first case repeats for string_res; rest run only from the passthru string layer.
+    // Similarly, the manipulator breadth isn't checked at the cstring layer either.
+    {
+        // S: string, no manipulator
+        void echoTillX(const char * casename) {
+            string s;
+            do {
+                forceStringHeapFreeSpaceTo(9);
+                sin | s;
+                sout | casename | s;
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+        }
+        echoTillX("preS1");
+        echoTillX("preS2");
+        echoTillX("preS3");
+        echoTillX("preS4");
+    }
+    {
+        // SMN: string, manipulator for no-op
+        void echoTillX(const char * casename) {
+            string s;
+            do {
+                sin | plainjane( s );
+                sout | casename | s;
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+        }
+        echoTillX("preSMN1");
+        echoTillX("preSMN2");
+        echoTillX("preSMN3");
+        echoTillX("preSMN4");
+    }
+    {
+        // RMN: string_res, manipulator for no-op
+        void echoTillX(const char * casename) {
+            string_res s;
+            do {
+                sin | plainjane( s );
+                sout | casename | s;
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+        }
+        echoTillX("preRMN1");
+        echoTillX("preRMN2");
+        echoTillX("preRMN3");
+        echoTillX("preRMN4");
+    }
+    {
+        // SMI: string, manipulator `incl`
+        void echoTillX(const char * casename) {
+            string s;
+            do {
+                sin | skip("-\n");
+                sin | incl( ".:|# x", s );
+                sout | casename | " \"" | s | "\"";
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+        }
+        echoTillX("preSMI1");
+        echoTillX("preSMI2");
+        echoTillX("preSMI3");
+        echoTillX("preSMI4");
+    }
+    {
+        // SME: string, manipulator `excl`
+        void echoTillX(const char * casename) {
+            string s;
+            do {
+                sin | skip("-\n");
+                sin | excl( "-\n", s );
+                sout | casename | " \"" | s | "\"";
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+        }
+        echoTillX("preSME1");
+        echoTillX("preSME2");
+        echoTillX("preSME3");
+        echoTillX("preSME4");
+    }
+    sin | skip("-\n");
+    {
+        // SMG: string, manipulator `getline`
+        void echoTillX(const char * casename) {
+            string s;
+            do {
+                sin | getline( s );
+                sout | casename | s;
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+        }
+        echoTillX("preSMG1");
+        echoTillX("preSMG2");
+        echoTillX("preSMG3");
+        echoTillX("preSMG4");
+    }
+    {
+        // SMD: string, manipulator (`getline` with custom) delimiter
+        void echoTillX(const char * casename) {
+            string s;
+            do {
+                sin | getline( s, '@' );
+                sout | casename | s;
+            } while ( size(s) > 0 && s[size(s)-1] != 'x' );
+            sin | skip(" \n");
+        }
+        echoTillX("preSMD1");
+        echoTillX("preSMD2");
+        echoTillX("preSMD3");
+        echoTillX("preSMD4");
+    }
+
     /* Keep harmonized with io/manipulatorsInput */
     {
@@ -23 +156 @@
         sin | ignore( incl( "abc", wdi( 8, s ) ) );     sout | "12" | s;
         sin | ignore( excl( "abc", wdi( 8, s ) ) );     sout | "13" | s;
-    }
+
+                s = "q";
+                sin | incl( "abc", s );                         sout | "14" | s;
+                s = "q";
+                sin | excl( "u", s );                           sout | "15" | s;
+                sin | skip( "u" );
+                sin | "\n";
+        }
+    // Full repeat on string_res layer assures the full manipulator vocabulary is supported there.
     {
         string_res s = "yyyyyyyyyyyyyyyyyyyy";
@@ -41 +182 @@
         sin | ignore( incl( "abc", wdi( 8, s ) ) );     sout | "12" | s;
         sin | ignore( excl( "abc", wdi( 8, s ) ) );     sout | "13" | s;
+
+                s = "q";
+                sin | incl( "abc", s );                         sout | "14" | s;
+                s = "q";
+                sin | excl( "u", s );                           sout | "15" | s;
+                sin | skip( "u" );
+                sin | "\n";
     }
 }

tests/errors/.expect/scope.txt

@@ -1 @@
-errors/scope.cfa:2:1 error: duplicate object definition for thisIsAnError: signed int
-errors/scope.cfa:20:1 error: duplicate function definition for butThisIsAnError: function
+errors/scope.cfa:13:1 error: duplicate object definition for thisIsAnError: signed int
+errors/scope.cfa:30:1 error: duplicate function definition for butThisIsAnError: function
 ... with parameters
   double

tests/errors/scope.cfa

@@ -1 @@
-int thisIsAnError;
-int thisIsAnError;
+// Keep harmonized with errors/scope.
 
-int thisIsNotAnError;
-float thisIsNotAnError;
+#ifdef OMIT_DRIVING_REJECTIONS
+// For manual sanity checking:
+// Leave out the offensive declarations and verify that what's left is accepted.
+#define EXPREJ(...)
+#else 
+#define EXPREJ(...) __VA_ARGS__
+#endif
 
-int thisIsAlsoNotAnError() {
-  int thisIsNotAnError;
-}
 
-int thisIsAlsoNotAnError( double x ) {
-}
+        int thisIsAnError;
+EXPREJ( int thisIsAnError; )
 
-double thisIsStillNotAnError( double );
-double thisIsStillNotAnError( double );
+        int thisIsNotAnError;
+        float thisIsNotAnError;
 
-double butThisIsAnError( double ) {
-}
+        int thisIsAlsoNotAnError() {
+          int thisIsNotAnError;
+        }
 
-double butThisIsAnError( double ) {
-}
+        int thisIsAlsoNotAnError( double x ) {
+        }
+
+        double thisIsStillNotAnError( double );
+        double thisIsStillNotAnError( double );
+
+        double butThisIsAnError( double ) {
+        }
+EXPREJ(
+        double butThisIsAnError( double ) {
+        }
+)
 
 // Local Variables: //

tests/io/.expect/manipulatorsInput.arm64.txt

@@ -1 +1 @@
 pre1 "123456", canary ok
-pre2a "1234567", exception occurred, canary ok
-pre2b "89", canary ok
+pre2 "1234567", canary ok
+pre3a "1234567", exception occurred, canary ok
+pre3b "8", canary ok
+pre4a "1234567", exception occurred, canary ok
+pre4b "89", canary ok
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -15 +18 @@
 12 wwwwwwww
 13 wwwwwwww
+14 rc=1, cccc
+15 rc=0, q
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -28 +33 @@
 12 wwwwwwww
 13 wwwwwwww
+14 cccc
+15
 a
 a

tests/io/.expect/manipulatorsInput.x64.txt

@@ -1 +1 @@
 pre1 "123456", canary ok
-pre2a "1234567", exception occurred, canary ok
-pre2b "89", canary ok
+pre2 "1234567", canary ok
+pre3a "1234567", exception occurred, canary ok
+pre3b "8", canary ok
+pre4a "1234567", exception occurred, canary ok
+pre4b "89", canary ok
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -15 +18 @@
 12 wwwwwwww
 13 wwwwwwww
+14 rc=1, cccc
+15 rc=0, q
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -28 +33 @@
 12 wwwwwwww
 13 wwwwwwww
+14 cccc
+15
 a
 a

tests/io/.expect/manipulatorsInput.x86.txt

@@ -1 +1 @@
 pre1 "123456", canary ok
-pre2a "1234567", exception occurred, canary ok
-pre2b "89", canary ok
+pre2 "1234567", canary ok
+pre3a "1234567", exception occurred, canary ok
+pre3b "8", canary ok
+pre4a "1234567", exception occurred, canary ok
+pre4b "89", canary ok
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -15 +18 @@
 12 wwwwwwww
 13 wwwwwwww
+14 rc=1, cccc
+15 rc=0, q
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx
@@ -28 +33 @@
 12 wwwwwwww
 13 wwwwwwww
+14 cccc
+15
 a
 a

tests/io/.in/manipulatorsInput.txt

@@ -1 +1 @@
 123456
+1234567
+12345678
 123456789
 abc 
-abc 
+cccccb 
 xx
 abcxxx
 abcyyy
 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
+uuuuuccccuuuuu
 abc 
-abc 
+cccccb 
 xx
 abcxxx
 abcyyy
 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
+uuuuuccccuuuuu
 ab
 0xff 017 15-15

tests/io/manipulatorsInput.cfa

@@ -45 +45 @@
                 }
 
-                rep("pre1");
-                rep("pre2a");
-                rep("pre2b");
+                rep("pre1");    // 123456     |  123456
+                rep("pre2");    // 1234567    |  1234567
+                rep("pre3a");   // 12345678   |  1234567
+                rep("pre3b");   //            |  8
+                rep("pre4a");   // 123456789  |  1234567
+                rep("pre4b");   //            |  89
+
                 scanf("\n");  // next test does not start with %s so does not tolerate leading whitespace
         }
         {
                 char s[] = "yyyyyyyyyyyyyyyyyyyy";
-                const char sk[] = "abc";
-                scanf( "abc " ); scanf( sk ); for ( 5 ) scanf( "%*c" ); printf( "1 %s\n", s );
+                const char sk_fmt[] = "%*[abc]";
+                scanf( "abc " ); scanf( sk_fmt ); for ( 5 ) scanf( "%*c" ); printf( "1 %s\n", s );
                 scanf( "%s", s );                                                               printf( "2 %s\n", s );
                 scanf( "%*s" );                                                                 printf( "3 %s\n", s );
@@ -67 +71 @@
                 scanf( "%*8[abc]" );                                                    printf( "12 %s\n", s );
                 scanf( "%*8[^abc]" );                                                   printf( "13 %s\n", s );
+
+                int rc;
+                s[0] = 'q'; s[1] = '\0'; rc = 99;
+                rc = scanf( "%[abc]", s );                                              printf( "14 rc=%d, %s\n", rc, s );
+                s[0] = 'q'; s[1] = '\0'; rc = 99;
+                rc = scanf( "%[^u]", s );                                               printf( "15 rc=%d, %s\n", rc, s );
+                scanf( "%*[u]" );
+                scanf("\n");
         }
         {
@@ -85 +97 @@
                 sin | ignore( incl( "abc", wdi( sizeof(s), 8, s ) ) ); sout | "12" | s;
                 sin | ignore( excl( "abc", wdi( sizeof(s), 8, s ) ) ); sout | "13" | s;
+
+                s[0] = 'q'; s[1] = '\0';
+                sin | incl( "abc", wdi( sizeof(s), s ) );               sout | "14" | s;
+                s[0] = 'q'; s[1] = '\0';
+                sin | excl( "u", wdi( sizeof(s), s ) );                 sout | "15" | s;
+                sin | skip( "u" );
+                sin | "\n";
         }
     /* Keep harmonized with collections/string-istream-manip */

tests/test.py

@@ -116 +116 @@
         parser.add_argument('--no-invariant', help='Tell the compiler not to check invariants.', action='store_false', dest='invariant')
         parser.add_argument('--invariant', help='Tell the compiler to check invariants.', action='store_const', const=True)
-        parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=180)
+        parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=240)
         parser.add_argument('--global-timeout', help='Maximum cumulative duration in seconds after the ALL tests are considered to have timed out', type=int, default=7200)
         parser.add_argument('--timeout-with-gdb', help='Instead of killing the command when it times out, orphan it and print process id to allow gdb to attach', type=yes_no, default="no")

tools/build/cfa.m4

@@ -67 +67 @@
                 "x86_64"     ) cannon_arch_name="x64";;
                 "aarch64"    ) cannon_arch_name="arm64";;
-                "arm4"       ) cannon_arch_name="arm64";;
+                "arm64"      ) cannon_arch_name="arm64";;
                 "ARM64"      ) cannon_arch_name="arm64";;
                 "x86"        ) cannon_arch_name="x86";;