Index: doc/LaTeXmacros/common.tex =================================================================== --- doc/LaTeXmacros/common.tex (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ doc/LaTeXmacros/common.tex (revision 077810d99973b2543325df49a6b292650323694f) @@ -42,4 +42,5 @@ \newcommand{\CCfourteen}{\rm C\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name \newcommand{\CCseventeen}{\rm C\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name +\newcommand{\CCtwenty}{\rm C\kern-.1em\hbox{+\kern-.25em+}20} % C++20 symbolic name \newcommand{\Celeven}{C11\xspace} % C11 symbolic name \newcommand{\Csharp}{C\raisebox{0.4ex}{\#}\xspace} % C# symbolic name @@ -200,4 +201,5 @@ \newcommand{\opt}{$_{opt}$\ } +\usepackage{varioref} % extended references % adjust varioref package with default "section" and "page" titles, and optional title with faraway page numbers % \VRef{label} => Section 2.7, \VPageref{label} => page 17 @@ -251,5 +253,5 @@ _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__, fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,one_t,otype,restrict,_Static_assert, - _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,zero_t}, + _Thread_local,throw,throwResume,trait,try,ttype,typeof,__typeof,__typeof__,zero_t}, }% Index: doc/generic_types/generic_types.tex =================================================================== --- doc/generic_types/generic_types.tex (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ doc/generic_types/generic_types.tex (revision 077810d99973b2543325df49a6b292650323694f) @@ -148,5 +148,5 @@ \label{sec:poly-fns} -\CFA{}'s polymorphism was originally formalized by \citet{Ditchfield92}, and first implemented by \citet{Bilson03}. The signature feature of \CFA{} is parametric-polymorphic functions; such functions are written using a @forall@ clause (which gives the language its name): +\CFA{}'s polymorphism was originally formalized by \citet{Ditchfield92}, and first implemented by \citet{Bilson03}. The signature feature of \CFA{} is parametric-polymorphic functions; such functions are written using a @forall@ clause (which gives the language its name): \begin{lstlisting} forall(otype T) @@ -174,6 +174,6 @@ forall(otype S | { S ?+?(S, S); }) S twice(S x) { return x + x; } // (2) -\end{lstlisting} -This version of @twice@ works for any type @S@ that has an addition operator defined for it, and it could have been used to satisfy the type assertion on @four_times@. +\end{lstlisting} +This version of @twice@ works for any type @S@ that has an addition operator defined for it, and it could have been used to satisfy the type assertion on @four_times@. The translator accomplishes this polymorphism by creating a wrapper function calling @twice // (2)@ with @S@ bound to @double@, then providing this wrapper function to @four_times@\footnote{\lstinline@twice // (2)@ could also have had a type parameter named \lstinline@T@; \CFA{} specifies renaming of the type parameters, which would avoid the name conflict with the type variable \lstinline@T@ of \lstinline@four_times@.}. @@ -196,5 +196,5 @@ forall(otype M | has_magnitude(M)) M max_magnitude( M a, M b ) { - return abs(a) < abs(b) ? b : a; + return abs(a) < abs(b) ? b : a; } \end{lstlisting} @@ -213,9 +213,9 @@ Given the information provided for an @otype@, variables of polymorphic type can be treated as if they were a complete struct type -- they can be stack-allocated using the @alloca@ compiler builtin, default or copy-initialized, assigned, and deleted. As an example, the @abs@ function above produces generated code something like the following (simplified for clarity and brevity): \begin{lstlisting} -void abs( size_t _sizeof_M, size_t _alignof_M, - void (*_ctor_M)(void*), void (*_copy_M)(void*, void*), - void (*_assign_M)(void*, void*), void (*_dtor_M)(void*), - bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*), - void (*_ctor_M_zero)(void*, int), +void abs( size_t _sizeof_M, size_t _alignof_M, + void (*_ctor_M)(void*), void (*_copy_M)(void*, void*), + void (*_assign_M)(void*, void*), void (*_dtor_M)(void*), + bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*), + void (*_ctor_M_zero)(void*, int), void* m, void* _rtn ) { // polymorphic parameter and return passed as void* // M zero = { 0 }; @@ -223,5 +223,5 @@ _ctor_M_zero(zero, 0); // initialize using zero_t constructor // return m < zero ? -m : m; - void *_tmp = alloca(_sizeof_M) + void *_tmp = alloca(_sizeof_M); _copy_M( _rtn, // copy-initialize return value _lt_M( m, zero ) ? // check condition @@ -323,5 +323,5 @@ In some cases the offset arrays cannot be statically generated. For instance, modularity is generally provided in C by including an opaque forward-declaration of a struct and associated accessor and mutator routines in a header file, with the actual implementations in a separately-compiled \texttt{.c} file. \CFA{} supports this pattern for generic types, and in this instance the caller does not know the actual layout or size of the dynamic generic type, and only holds it by pointer. The \CFA{} translator automatically generates \emph{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed in to a function from that function's caller. These layout functions take as arguments pointers to size and alignment variables and a caller-allocated array of member offsets, as well as the size and alignment of all @sized@ parameters to the generic struct (un-@sized@ parameters are forbidden from the language from being used in a context that affects layout). Results of these layout functions are cached so that they are only computed once per type per function.%, as in the example below for @pair@. % \begin{lstlisting} -% static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair, +% static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair, % size_t _szeof_R, size_t _alignof_R, size_t _szeof_S, size_t _alignof_S) { % *_szeof_pair = 0; // default values @@ -332,5 +332,5 @@ % *_szeof_pair += _szeof_R; % if ( *_alignof_pair < _alignof_R ) *_alignof_pair = _alignof_R; - + % // padding, offset, size, and alignment of second field % if ( *_szeof_pair & (_alignof_S - 1) ) @@ -754,5 +754,5 @@ f(x.field_0, (_tuple2){ x.field_1, 'z' }); \end{lstlisting} -Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. In the call to @f@, a the second and third argument components are structured into a tuple argument. Similarly, tuple member expressions are recursively expanded into a list of member access expressions. +Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. In the call to @f@, the second and third argument components are structured into a tuple argument. Similarly, tuple member expressions are recursively expanded into a list of member access expressions. Expressions that may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion. Each unique expression is assigned an identifier and is guaranteed to be executed exactly once: @@ -774,5 +774,5 @@ ); \end{lstlisting} -Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. Tuple member expressions also take advantage of unique expressions in the case of possible impurity. +Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. Tuple member expressions also take advantage of unique expressions in the case of possible impurity. Currently, the \CFA{} translator has a very broad, imprecise definition of impurity, where any function call is assumed to be impure. This notion could be made more precise for certain intrinsic, auto-generated, and builtin functions, and could analyze function bodies when they are available to recursively detect impurity, to eliminate some unique expressions. Index: doc/rob_thesis/ctordtor.tex =================================================================== --- doc/rob_thesis/ctordtor.tex (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ doc/rob_thesis/ctordtor.tex (revision 077810d99973b2543325df49a6b292650323694f) @@ -135,8 +135,4 @@ % at the global scope (which is likely the most common case) % * [9] - -% Move semantics -% * % Changes to polymorphic type classes Index: doc/rob_thesis/tuples.tex =================================================================== --- doc/rob_thesis/tuples.tex (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ doc/rob_thesis/tuples.tex (revision 077810d99973b2543325df49a6b292650323694f) @@ -615,5 +615,5 @@ \end{cfacode} Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. -In the call to @f@, a the second and third argument components are structured into a tuple argument. +In the call to @f@, the second and third argument components are structured into a tuple argument. Expressions which may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion. @@ -643,5 +643,5 @@ \end{cfacode} Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. -The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true. +The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. @@ -1299,2 +1299,4 @@ Thunks 0 through 3 provide wrappers for the @otype@ parameters for @const char *@, while @_thunk4@ translates a call to @print([int, const char *])@ into a call to @print_variadic(int, [const char *])@. This all builds to a call to @print_variadic@, with the appropriate copy construction of the tuple argument. + +\section{Future Work} Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/CodeGen/CodeGenerator.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 17 09:06:01 2017 -// Update Count : 481 +// Last Modified On : Thu Mar 30 16:38:01 2017 +// Update Count : 482 // @@ -674,6 +674,6 @@ void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) { - assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) ); - output << "(" << genType( compLitExpr->get_type(), "", pretty ) << ")"; + assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) ); + output << "(" << genType( compLitExpr->get_result(), "", pretty ) << ")"; compLitExpr->get_initializer()->accept( *this ); } Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/InitTweak/FixInit.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -738,10 +738,14 @@ stmtsToAddAfter.push_back( ifStmt ); - if ( ctorInit->get_dtor() ) { + Statement * dtor = ctorInit->get_dtor(); + objDecl->set_init( NULL ); + ctorInit->set_ctor( NULL ); + ctorInit->set_dtor( nullptr ); + if ( dtor ) { // if the object has a non-trivial destructor, have to // hoist it and the object into the global space and // call the destructor function with atexit. - Statement * dtorStmt = ctorInit->get_dtor()->clone(); + Statement * dtorStmt = dtor->clone(); // void __objName_dtor_atexitN(...) {...} @@ -772,12 +776,9 @@ objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) ); - objDecl->set_init( NULL ); - ctorInit->set_ctor( NULL ); - delete ctorInit; - // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope // create a new object which is never used static UniqueName dummyNamer( "_dummy" ); ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } ); + delete ctorInit; return dummy; } Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/InitTweak/GenInit.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -294,8 +294,8 @@ handleDWT( objDecl ); // hands off if @=, extern, builtin, etc. - // if global but initializer is not constexpr, always try to construct, since this is not legal C - if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) { + // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C + if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) { // constructed objects cannot be designated - if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl ); + if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl ); // constructed objects should not have initializers nested too deeply if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl ); Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/Parser/ExpressionNode.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Mar 4 06:58:47 2017 -// Update Count : 509 +// Last Modified On : Thu Mar 30 17:02:46 2017 +// Update Count : 515 // @@ -356,9 +356,21 @@ // these types do not have associated type information } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl ) ) { - return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + if ( newDeclStructDecl->has_body() ) { + return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) ); + } else { + return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + } // if } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl ) ) { - return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + if ( newDeclUnionDecl->has_body() ) { + return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) ); + } else { + return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + } // if } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl ) ) { - return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + if ( newDeclEnumDecl->has_body() ) { + return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) ); + } else { + return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + } // if } else { assert( false ); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/Parser/parser.yy (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 17 15:42:22 2017 -// Update Count : 2317 +// Last Modified On : Thu Mar 30 15:42:32 2017 +// Update Count : 2318 // @@ -423,5 +423,5 @@ | postfix_expression DECR { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); } - | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99 + | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); } | postfix_expression '{' argument_expression_list '}' // CFA Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/SymTab/Indexer.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:37:33 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 14 08:07:34 2017 -// Update Count : 17 +// Last Modified On : Thu Mar 30 16:38:47 2017 +// Update Count : 19 // @@ -483,5 +483,4 @@ void Indexer::visit( CompoundLiteralExpr *compLitExpr ) { acceptNewScope( compLitExpr->get_result(), *this ); - maybeAccept( compLitExpr->get_type(), *this ); maybeAccept( compLitExpr->get_initializer(), *this ); } Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/SymTab/Validate.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:50:04 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Mar 16 16:39:15 2017 -// Update Count : 353 +// Last Modified On : Thu Mar 30 16:50:13 2017 +// Update Count : 357 // @@ -222,6 +222,6 @@ CompoundLiteral compoundliteral; + HoistStruct::hoistStruct( translationUnit ); EliminateTypedef::eliminateTypedef( translationUnit ); - HoistStruct::hoistStruct( translationUnit ); ReturnTypeFixer::fix( translationUnit ); // must happen before autogen acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions @@ -824,6 +824,6 @@ static UniqueName indexName( "_compLit" ); - ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() ); - compLitExpr->set_type( 0 ); + ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() ); + compLitExpr->set_result( 0 ); compLitExpr->set_initializer( 0 ); delete compLitExpr; Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/SynTree/Expression.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 17 09:42:04 2017 -// Update Count : 51 +// Last Modified On : Thu Mar 30 16:41:13 2017 +// Update Count : 52 // @@ -571,14 +571,13 @@ -CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) { +CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) { assert( type && initializer ); - set_result( type->clone() ); -} - -CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {} + set_result( type ); +} + +CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {} CompoundLiteralExpr::~CompoundLiteralExpr() { delete initializer; - delete type; } @@ -586,5 +585,5 @@ os << "Compound Literal Expression: " << std::endl; os << std::string( indent+2, ' ' ); - type->print( os, indent + 2 ); + get_result()->print( os, indent + 2 ); os << std::string( indent+2, ' ' ); initializer->print( os, indent + 2 ); Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/SynTree/Expression.h (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jan 14 14:37:54 2017 -// Update Count : 37 +// Last Modified On : Thu Mar 30 16:44:00 2017 +// Update Count : 41 // @@ -35,4 +35,5 @@ Type *& get_result() { return result; } + const Type * get_result() const { return result; } void set_result( Type * newValue ) { result = newValue; } bool has_result() const { return result != nullptr; } @@ -586,7 +587,4 @@ virtual ~CompoundLiteralExpr(); - Type * get_type() const { return type; } - void set_type( Type * t ) { type = t; } - Initializer * get_initializer() const { return initializer; } void set_initializer( Initializer * i ) { initializer = i; } @@ -597,5 +595,4 @@ virtual void print( std::ostream & os, int indent = 0 ) const; private: - Type * type; Initializer * initializer; }; Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/SynTree/Mutator.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 15:02:23 2017 -// Update Count : 21 +// Last Modified On : Thu Mar 30 16:45:19 2017 +// Update Count : 22 // @@ -369,5 +369,4 @@ compLitExpr->set_env( maybeMutate( compLitExpr->get_env(), *this ) ); compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) ); - compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) ); compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) ); return compLitExpr; Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/SynTree/Visitor.cc (revision 077810d99973b2543325df49a6b292650323694f) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 16 15:01:25 2017 -// Update Count : 23 +// Last Modified On : Thu Mar 30 16:45:25 2017 +// Update Count : 24 // @@ -292,5 +292,4 @@ void Visitor::visit( CompoundLiteralExpr *compLitExpr ) { maybeAccept( compLitExpr->get_result(), *this ); - maybeAccept( compLitExpr->get_type(), *this ); maybeAccept( compLitExpr->get_initializer(), *this ); } Index: src/libcfa/iostream.c =================================================================== --- src/libcfa/iostream.c (revision 9d944b2a97f0468ab2208567dbc494494cf66a93) +++ src/libcfa/iostream.c (revision 077810d99973b2543325df49a6b292650323694f) @@ -154,5 +154,5 @@ ostype * ?|?( ostype * os, const char * cp ) { enum { Open = 1, Close, OpenClose }; - static const unsigned char mask[256] = { + static const unsigned char mask[256] @= { // opening delimiters, no space after ['('] : Open, ['['] : Open, ['{'] : Open,