Changeset 077810d


Ignore:
Timestamp:
Mar 31, 2017, 12:16:19 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
24c18ea, 78d3dd5
Parents:
9d944b2 (diff), 936a287 (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:
16 edited

Legend:

Unmodified
Added
Removed
  • doc/LaTeXmacros/common.tex

    r9d944b2 r077810d  
    4242\newcommand{\CCfourteen}{\rm C\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name
    4343\newcommand{\CCseventeen}{\rm C\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name
     44\newcommand{\CCtwenty}{\rm C\kern-.1em\hbox{+\kern-.25em+}20} % C++20 symbolic name
    4445\newcommand{\Celeven}{C11\xspace}               % C11 symbolic name
    4546\newcommand{\Csharp}{C\raisebox{0.4ex}{\#}\xspace}      % C# symbolic name
     
    200201\newcommand{\opt}{$_{opt}$\ }
    201202
     203\usepackage{varioref}                 % extended references
    202204% adjust varioref package with default "section" and "page" titles, and optional title with faraway page numbers
    203205% \VRef{label} => Section 2.7, \VPageref{label} => page 17
     
    251253                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    252254                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,one_t,otype,restrict,_Static_assert,
    253                 _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,zero_t},
     255                _Thread_local,throw,throwResume,trait,try,ttype,typeof,__typeof,__typeof__,zero_t},
    254256}%
    255257
  • doc/generic_types/generic_types.tex

    r9d944b2 r077810d  
    148148\label{sec:poly-fns}
    149149
    150 \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): 
     150\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):
    151151\begin{lstlisting}
    152152forall(otype T)
     
    174174forall(otype S | { S ?+?(S, S); })
    175175S twice(S x) { return x + x; }  // (2)
    176 \end{lstlisting} 
    177 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@. 
     176\end{lstlisting}
     177This 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@.
    178178The 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@.}.
    179179
     
    196196forall(otype M | has_magnitude(M))
    197197M max_magnitude( M a, M b ) {
    198     return abs(a) < abs(b) ? b : a; 
     198    return abs(a) < abs(b) ? b : a;
    199199}
    200200\end{lstlisting}
     
    213213Given 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):
    214214\begin{lstlisting}
    215 void abs( size_t _sizeof_M, size_t _alignof_M, 
    216                 void (*_ctor_M)(void*), void (*_copy_M)(void*, void*), 
    217                 void (*_assign_M)(void*, void*), void (*_dtor_M)(void*), 
    218                 bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*), 
    219         void (*_ctor_M_zero)(void*, int), 
     215void abs( size_t _sizeof_M, size_t _alignof_M,
     216                void (*_ctor_M)(void*), void (*_copy_M)(void*, void*),
     217                void (*_assign_M)(void*, void*), void (*_dtor_M)(void*),
     218                bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*),
     219        void (*_ctor_M_zero)(void*, int),
    220220                void* m, void* _rtn ) {  // polymorphic parameter and return passed as void*
    221221        // M zero = { 0 };
     
    223223        _ctor_M_zero(zero, 0);  // initialize using zero_t constructor
    224224        // return m < zero ? -m : m;
    225         void *_tmp = alloca(_sizeof_M)
     225        void *_tmp = alloca(_sizeof_M);
    226226        _copy_M( _rtn,  // copy-initialize return value
    227227                _lt_M( m, zero ) ?  // check condition
     
    323323In 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@.
    324324% \begin{lstlisting}
    325 % static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair, 
     325% static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair,
    326326%               size_t _szeof_R, size_t _alignof_R, size_t _szeof_S, size_t _alignof_S) {
    327327%     *_szeof_pair = 0; // default values
     
    332332%     *_szeof_pair += _szeof_R;
    333333%     if ( *_alignof_pair < _alignof_R ) *_alignof_pair = _alignof_R;
    334        
     334
    335335%       // padding, offset, size, and alignment of second field
    336336%     if ( *_szeof_pair & (_alignof_S - 1) )
     
    754754f(x.field_0, (_tuple2){ x.field_1, 'z' });
    755755\end{lstlisting}
    756 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.
     756Note 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.
    757757
    758758Expressions 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:
     
    774774);
    775775\end{lstlisting}
    776 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.
     776Since 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.
    777777
    778778Currently, 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.
  • doc/rob_thesis/ctordtor.tex

    r9d944b2 r077810d  
    135135%   at the global scope (which is likely the most common case)
    136136% * [9]
    137 
    138 % Move semantics
    139 % * <ongoing discussion about this. this will be filled in
    140 %    once we come to a consensus>
    141137
    142138% Changes to polymorphic type classes
  • doc/rob_thesis/tuples.tex

    r9d944b2 r077810d  
    615615\end{cfacode}
    616616Note that due to flattening, @x@ used in the argument position is converted into the list of its fields.
    617 In the call to @f@, a the second and third argument components are structured into a tuple argument.
     617In the call to @f@, the second and third argument components are structured into a tuple argument.
    618618
    619619Expressions which may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion.
     
    643643\end{cfacode}
    644644Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order.
    645 The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true.
     645The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true.
    646646Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression.
    647647
     
    12991299Thunks 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 *])@.
    13001300This all builds to a call to @print_variadic@, with the appropriate copy construction of the tuple argument.
     1301
     1302\section{Future Work}
  • src/CodeGen/CodeGenerator.cc

    r9d944b2 r077810d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 17 09:06:01 2017
    13 // Update Count     : 481
     12// Last Modified On : Thu Mar 30 16:38:01 2017
     13// Update Count     : 482
    1414//
    1515
     
    674674
    675675        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
    676                 assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
    677                 output << "(" << genType( compLitExpr->get_type(), "", pretty ) << ")";
     676                assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
     677                output << "(" << genType( compLitExpr->get_result(), "", pretty ) << ")";
    678678                compLitExpr->get_initializer()->accept( *this );
    679679        }
  • src/InitTweak/FixInit.cc

    r9d944b2 r077810d  
    738738                                                stmtsToAddAfter.push_back( ifStmt );
    739739
    740                                                 if ( ctorInit->get_dtor() ) {
     740                                                Statement * dtor = ctorInit->get_dtor();
     741                                                objDecl->set_init( NULL );
     742                                                ctorInit->set_ctor( NULL );
     743                                                ctorInit->set_dtor( nullptr );
     744                                                if ( dtor ) {
    741745                                                        // if the object has a non-trivial destructor, have to
    742746                                                        // hoist it and the object into the global space and
    743747                                                        // call the destructor function with atexit.
    744748
    745                                                         Statement * dtorStmt = ctorInit->get_dtor()->clone();
     749                                                        Statement * dtorStmt = dtor->clone();
    746750
    747751                                                        // void __objName_dtor_atexitN(...) {...}
     
    772776                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
    773777
    774                                                         objDecl->set_init( NULL );
    775                                                         ctorInit->set_ctor( NULL );
    776                                                         delete ctorInit;
    777 
    778778                                                        // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
    779779                                                        // create a new object which is never used
    780780                                                        static UniqueName dummyNamer( "_dummy" );
    781781                                                        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") } );
     782                                                        delete ctorInit;
    782783                                                        return dummy;
    783784                                                }
  • src/InitTweak/GenInit.cc

    r9d944b2 r077810d  
    294294                handleDWT( objDecl );
    295295                // hands off if @=, extern, builtin, etc.
    296                 // if global but initializer is not constexpr, always try to construct, since this is not legal C
    297                 if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) {
     296                // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
     297                if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
    298298                        // constructed objects cannot be designated
    299                         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 );
     299                        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 );
    300300                        // constructed objects should not have initializers nested too deeply
    301301                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
  • src/Parser/ExpressionNode.cc

    r9d944b2 r077810d  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Mar  4 06:58:47 2017
    13 // Update Count     : 509
     12// Last Modified On : Thu Mar 30 17:02:46 2017
     13// Update Count     : 515
    1414//
    1515
     
    356356        // these types do not have associated type information
    357357        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
    358                 return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
     358                if ( newDeclStructDecl->has_body() ) {
     359                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) );
     360                } else {
     361                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
     362                } // if
    359363        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
    360                 return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
     364                if ( newDeclUnionDecl->has_body() ) {
     365                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) );
     366                } else {
     367                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
     368                } // if
    361369        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
    362                 return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
     370                if ( newDeclEnumDecl->has_body() ) {
     371                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) );
     372                } else {
     373                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
     374                } // if
    363375        } else {
    364376                assert( false );
  • src/Parser/parser.yy

    r9d944b2 r077810d  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 17 15:42:22 2017
    13 // Update Count     : 2317
     12// Last Modified On : Thu Mar 30 15:42:32 2017
     13// Update Count     : 2318
    1414//
    1515
     
    423423        | postfix_expression DECR
    424424                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
    425         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
     425        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
    426426                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
    427427        | postfix_expression '{' argument_expression_list '}' // CFA
  • src/SymTab/Indexer.cc

    r9d944b2 r077810d  
    1010// Created On       : Sun May 17 21:37:33 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 08:07:34 2017
    13 // Update Count     : 17
     12// Last Modified On : Thu Mar 30 16:38:47 2017
     13// Update Count     : 19
    1414//
    1515
     
    483483        void Indexer::visit( CompoundLiteralExpr *compLitExpr ) {
    484484                acceptNewScope( compLitExpr->get_result(), *this );
    485                 maybeAccept( compLitExpr->get_type(), *this );
    486485                maybeAccept( compLitExpr->get_initializer(), *this );
    487486        }
  • src/SymTab/Validate.cc

    r9d944b2 r077810d  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 16 16:39:15 2017
    13 // Update Count     : 353
     12// Last Modified On : Thu Mar 30 16:50:13 2017
     13// Update Count     : 357
    1414//
    1515
     
    222222                CompoundLiteral compoundliteral;
    223223
     224                HoistStruct::hoistStruct( translationUnit );
    224225                EliminateTypedef::eliminateTypedef( translationUnit );
    225                 HoistStruct::hoistStruct( translationUnit );
    226226                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
    227227                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
     
    824824                static UniqueName indexName( "_compLit" );
    825825
    826                 ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
    827                 compLitExpr->set_type( 0 );
     826                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
     827                compLitExpr->set_result( 0 );
    828828                compLitExpr->set_initializer( 0 );
    829829                delete compLitExpr;
  • src/SynTree/Expression.cc

    r9d944b2 r077810d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 17 09:42:04 2017
    13 // Update Count     : 51
     12// Last Modified On : Thu Mar 30 16:41:13 2017
     13// Update Count     : 52
    1414//
    1515
     
    571571
    572572
    573 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
     573CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
    574574        assert( type && initializer );
    575         set_result( type->clone() );
    576 }
    577 
    578 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
     575        set_result( type );
     576}
     577
     578CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
    579579
    580580CompoundLiteralExpr::~CompoundLiteralExpr() {
    581581        delete initializer;
    582         delete type;
    583582}
    584583
     
    586585        os << "Compound Literal Expression: " << std::endl;
    587586        os << std::string( indent+2, ' ' );
    588         type->print( os, indent + 2 );
     587        get_result()->print( os, indent + 2 );
    589588        os << std::string( indent+2, ' ' );
    590589        initializer->print( os, indent + 2 );
  • src/SynTree/Expression.h

    r9d944b2 r077810d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jan 14 14:37:54 2017
    13 // Update Count     : 37
     12// Last Modified On : Thu Mar 30 16:44:00 2017
     13// Update Count     : 41
    1414//
    1515
     
    3535
    3636        Type *& get_result() { return result; }
     37        const Type * get_result() const { return result; }
    3738        void set_result( Type * newValue ) { result = newValue; }
    3839        bool has_result() const { return result != nullptr; }
     
    586587        virtual ~CompoundLiteralExpr();
    587588
    588         Type * get_type() const { return type; }
    589         void set_type( Type * t ) { type = t; }
    590 
    591589        Initializer * get_initializer() const { return initializer; }
    592590        void set_initializer( Initializer * i ) { initializer = i; }
     
    597595        virtual void print( std::ostream & os, int indent = 0 ) const;
    598596  private:
    599         Type * type;
    600597        Initializer * initializer;
    601598};
  • src/SynTree/Mutator.cc

    r9d944b2 r077810d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 15:02:23 2017
    13 // Update Count     : 21
     12// Last Modified On : Thu Mar 30 16:45:19 2017
     13// Update Count     : 22
    1414//
    1515
     
    369369        compLitExpr->set_env( maybeMutate( compLitExpr->get_env(), *this ) );
    370370        compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
    371         compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
    372371        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
    373372        return compLitExpr;
  • src/SynTree/Visitor.cc

    r9d944b2 r077810d  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 16 15:01:25 2017
    13 // Update Count     : 23
     12// Last Modified On : Thu Mar 30 16:45:25 2017
     13// Update Count     : 24
    1414//
    1515
     
    292292void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
    293293        maybeAccept( compLitExpr->get_result(), *this );
    294         maybeAccept( compLitExpr->get_type(), *this );
    295294        maybeAccept( compLitExpr->get_initializer(), *this );
    296295}
  • src/libcfa/iostream.c

    r9d944b2 r077810d  
    154154ostype * ?|?( ostype * os, const char * cp ) {
    155155        enum { Open = 1, Close, OpenClose };
    156         static const unsigned char mask[256] = {
     156        static const unsigned char mask[256] @= {
    157157                // opening delimiters, no space after
    158158                ['('] : Open, ['['] : Open, ['{'] : Open,
Note: See TracChangeset for help on using the changeset viewer.