Changeset 154672d


Ignore:
Timestamp:
Sep 7, 2023, 10:05:33 AM (16 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
master
Children:
0f8b1a7
Parents:
79b05224 (diff), 416b443 (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:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/collections/string.cfa

    r79b05224 r154672d  
    157157// Comparison
    158158
    159 bool ?==?(const string & s, const string & other) {
    160     return *s.inner == *other.inner;
    161 }
    162 
    163 bool ?!=?(const string & s, const string & other) {
    164     return *s.inner != *other.inner;
    165 }
    166 
    167 bool ?==?(const string & s, const char * other) {
    168     return *s.inner == other;
    169 }
    170 
    171 bool ?!=?(const string & s, const char * other) {
    172     return *s.inner != other;
    173 }
     159int  cmp (const string &s1, const string &s2) { return cmp(*s1.inner ,  *s2.inner); }
     160bool ?==?(const string &s1, const string &s2) { return     *s1.inner == *s2.inner ; }
     161bool ?!=?(const string &s1, const string &s2) { return     *s1.inner != *s2.inner ; }
     162bool ?>? (const string &s1, const string &s2) { return     *s1.inner >  *s2.inner ; }
     163bool ?>=?(const string &s1, const string &s2) { return     *s1.inner >= *s2.inner ; }
     164bool ?<=?(const string &s1, const string &s2) { return     *s1.inner <= *s2.inner ; }
     165bool ?<? (const string &s1, const string &s2) { return     *s1.inner <  *s2.inner ; }
     166
     167int  cmp (const string &s1, const char*   s2) { return cmp(*s1.inner ,   s2      ); }
     168bool ?==?(const string &s1, const char*   s2) { return     *s1.inner ==  s2       ; }
     169bool ?!=?(const string &s1, const char*   s2) { return     *s1.inner !=  s2       ; }
     170bool ?>? (const string &s1, const char*   s2) { return     *s1.inner >   s2       ; }
     171bool ?>=?(const string &s1, const char*   s2) { return     *s1.inner >=  s2       ; }
     172bool ?<=?(const string &s1, const char*   s2) { return     *s1.inner <=  s2       ; }
     173bool ?<? (const string &s1, const char*   s2) { return     *s1.inner <   s2       ; }
     174
     175int  cmp (const char*   s1, const string &s2) { return cmp( s1       ,  *s2.inner); }
     176bool ?==?(const char*   s1, const string &s2) { return      s1       == *s2.inner ; }
     177bool ?!=?(const char*   s1, const string &s2) { return      s1       != *s2.inner ; }
     178bool ?>? (const char*   s1, const string &s2) { return      s1       >  *s2.inner ; }
     179bool ?>=?(const char*   s1, const string &s2) { return      s1       >= *s2.inner ; }
     180bool ?<=?(const char*   s1, const string &s2) { return      s1       <= *s2.inner ; }
     181bool ?<? (const char*   s1, const string &s2) { return      s1       <  *s2.inner ; }
     182
    174183
    175184////////////////////////////////////////////////////////

  • libcfa/src/collections/string.hfa

    r79b05224 r154672d  
    116116
    117117// Comparisons
    118 bool ?==?(const string & s, const string & other);
    119 bool ?!=?(const string & s, const string & other);
    120 bool ?==?(const string & s, const char * other);
    121 bool ?!=?(const string & s, const char * other);
     118int  cmp (const string &, const string &);
     119bool ?==?(const string &, const string &);
     120bool ?!=?(const string &, const string &);
     121bool ?>? (const string &, const string &);
     122bool ?>=?(const string &, const string &);
     123bool ?<=?(const string &, const string &);
     124bool ?<? (const string &, const string &);
     125
     126int  cmp (const string &, const char*);
     127bool ?==?(const string &, const char*);
     128bool ?!=?(const string &, const char*);
     129bool ?>? (const string &, const char*);
     130bool ?>=?(const string &, const char*);
     131bool ?<=?(const string &, const char*);
     132bool ?<? (const string &, const char*);
     133
     134int  cmp (const char*, const string &);
     135bool ?==?(const char*, const string &);
     136bool ?!=?(const char*, const string &);
     137bool ?>? (const char*, const string &);
     138bool ?>=?(const char*, const string &);
     139bool ?<=?(const char*, const string &);
     140bool ?<? (const char*, const string &);
     141
    122142
    123143// Slicing

  • libcfa/src/collections/string_res.cfa

    r79b05224 r154672d  
    637637// Comparisons
    638638
    639 
    640 bool ?==?(const string_res &s1, const string_res &s2) {
    641     return ByteCmp( s1.Handle.s, 0, s1.Handle.lnth, s2.Handle.s, 0, s2.Handle.lnth) == 0;
    642 }
    643 
    644 bool ?!=?(const string_res &s1, const string_res &s2) {
    645     return !(s1 == s2);
    646 }
    647 bool ?==?(const string_res &s, const char* other) {
    648     string_res sother = other;
    649     return s == sother;
    650 }
    651 bool ?!=?(const string_res &s, const char* other) {
    652     return !(s == other);
    653 }
     639int cmp(const string_res &s1, const string_res &s2) {
     640    // return 0;
     641    int ans1 = memcmp(s1.Handle.s, s2.Handle.s, min(s1.Handle.lnth, s2.Handle.lnth));
     642    if (ans1 != 0) return ans1;
     643    return s1.Handle.lnth - s2.Handle.lnth;
     644}
     645
     646bool ?==?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) == 0; }
     647bool ?!=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) != 0; }
     648bool ?>? (const string_res &s1, const string_res &s2) { return cmp(s1, s2) >  0; }
     649bool ?>=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) >= 0; }
     650bool ?<=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) <= 0; }
     651bool ?<? (const string_res &s1, const string_res &s2) { return cmp(s1, s2) <  0; }
     652
     653int cmp (const string_res &s1, const char* s2) {
     654    string_res s2x = s2;
     655    return cmp(s1, s2x);
     656}
     657
     658bool ?==?(const string_res &s1, const char* s2) { return cmp(s1, s2) == 0; }
     659bool ?!=?(const string_res &s1, const char* s2) { return cmp(s1, s2) != 0; }
     660bool ?>? (const string_res &s1, const char* s2) { return cmp(s1, s2) >  0; }
     661bool ?>=?(const string_res &s1, const char* s2) { return cmp(s1, s2) >= 0; }
     662bool ?<=?(const string_res &s1, const char* s2) { return cmp(s1, s2) <= 0; }
     663bool ?<? (const string_res &s1, const char* s2) { return cmp(s1, s2) <  0; }
     664
     665int cmp (const char* s1, const string_res & s2) {
     666    string_res s1x = s1;
     667    return cmp(s1x, s2);
     668}
     669
     670bool ?==?(const char* s1, const string_res &s2) { return cmp(s1, s2) == 0; }
     671bool ?!=?(const char* s1, const string_res &s2) { return cmp(s1, s2) != 0; }
     672bool ?>? (const char* s1, const string_res &s2) { return cmp(s1, s2) >  0; }
     673bool ?>=?(const char* s1, const string_res &s2) { return cmp(s1, s2) >= 0; }
     674bool ?<=?(const char* s1, const string_res &s2) { return cmp(s1, s2) <= 0; }
     675bool ?<? (const char* s1, const string_res &s2) { return cmp(s1, s2) <  0; }
     676
    654677
    655678

  • libcfa/src/collections/string_res.hfa

    r79b05224 r154672d  
    142142
    143143// Comparisons
    144 bool ?==?(const string_res &s, const string_res &other);
    145 bool ?!=?(const string_res &s, const string_res &other);
    146 bool ?==?(const string_res &s, const char* other);
    147 bool ?!=?(const string_res &s, const char* other);
     144int  cmp (const string_res &, const string_res &);
     145bool ?==?(const string_res &, const string_res &);
     146bool ?!=?(const string_res &, const string_res &);
     147bool ?>? (const string_res &, const string_res &);
     148bool ?>=?(const string_res &, const string_res &);
     149bool ?<=?(const string_res &, const string_res &);
     150bool ?<? (const string_res &, const string_res &);
     151
     152int  cmp (const string_res &, const char*);
     153bool ?==?(const string_res &, const char*);
     154bool ?!=?(const string_res &, const char*);
     155bool ?>? (const string_res &, const char*);
     156bool ?>=?(const string_res &, const char*);
     157bool ?<=?(const string_res &, const char*);
     158bool ?<? (const string_res &, const char*);
     159
     160int  cmp (const char*, const string_res &);
     161bool ?==?(const char*, const string_res &);
     162bool ?!=?(const char*, const string_res &);
     163bool ?>? (const char*, const string_res &);
     164bool ?>=?(const char*, const string_res &);
     165bool ?<=?(const char*, const string_res &);
     166bool ?<? (const char*, const string_res &);
    148167
    149168// String search

  • libcfa/src/concurrency/io.cfa

    r79b05224 r154672d  
    594594                lock( queue.lock __cfaabi_dbg_ctx2 );
    595595                {
    596                         was_empty = empty(queue.queue);
     596                        was_empty = queue.queue`isEmpty;
    597597
    598598                        // Add our request to the list
    599                         add( queue.queue, item );
     599                        insert_last( queue.queue, item );
    600600
    601601                        // Mark as pending
    … …  
    632632        // notify the arbiter that new allocations are available
    633633        static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) {
    634                 /* paranoid */ verify( !empty(this.pending.queue) );
     634                /* paranoid */ verify( !this.pending.queue`isEmpty );
    635635                /* paranoid */ verify( __preemption_enabled() );
    636636
    … …  
    642642                        // as long as there are pending allocations try to satisfy them
    643643                        // for simplicity do it in FIFO order
    644                         while( !empty(this.pending.queue) ) {
     644                        while( !this.pending.queue`isEmpty ) {
    645645                                // get first pending allocs
    646646                                __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
    647                                 __pending_alloc & pa = (__pending_alloc&)head( this.pending.queue );
     647                                __pending_alloc & pa = (__pending_alloc&)(this.pending.queue`first);
    648648
    649649                                // check if we have enough to satisfy the request
    … …  
    651651
    652652                                // if there are enough allocations it means we can drop the request
    653                                 drop( this.pending.queue );
     653                                try_pop_front( this.pending.queue );
    654654
    655655                                /* paranoid */__attribute__((unused)) bool ret =
    … …  
    727727                        // pop each operation one at a time.
    728728                        // There is no wait morphing because of the io sq ring
    729                         while( !empty(ctx.ext_sq.queue) ) {
     729                        while( !ctx.ext_sq.queue`isEmpty ) {
    730730                                // drop the element from the queue
    731                                 __external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
     731                                __external_io & ei = (__external_io&)try_pop_front( ctx.ext_sq.queue );
    732732
    733733                                // submit it

  • libcfa/src/concurrency/io/types.hfa

    r79b05224 r154672d  
    2424
    2525#include "bits/locks.hfa"
    26 #include "bits/queue.hfa"
    2726#include "iofwd.hfa"
    2827#include "kernel/fwd.hfa"
    2928
    3029#if defined(CFA_HAVE_LINUX_IO_URING_H)
    31         #include "bits/sequence.hfa"
    3230        #include "monitor.hfa"
    3331
    … …  
    120118        struct __outstanding_io {
    121119                // intrusive link fields
    122                 inline Colable;
     120                inline dlink(__outstanding_io);
    123121
    124122                // primitive on which to block until the io is processed
    125123                oneshot waitctx;
    126124        };
    127         static inline __outstanding_io *& Next( __outstanding_io * n ) { return (__outstanding_io *)Next( (Colable *)n ); }
     125    P9_EMBEDDED( __outstanding_io, dlink(__outstanding_io) )
    128126
    129127        // queue of operations that are outstanding
    … …  
    134132
    135133                // the actual queue
    136                 Queue(__outstanding_io) queue;
     134                dlist(__outstanding_io) queue;
    137135
    138136                // volatile used to avoid the need for taking the lock if it's empty

  • libcfa/src/concurrency/pthread.cfa

    r79b05224 r154672d  
    2020#include <errno.h>
    2121#include "locks.hfa"
    22 #include "bits/stack.hfa"
    23 #include "bits/sequence.hfa"
    24 
    2522
    2623#define check_nonnull(x) asm("": "+rm"(x)); if( x == 0p ) return EINVAL;
    … …  
    3431
    3532struct pthread_values{
    36         inline Seqable;
     33        inline dlink(pthread_values);
    3734        void * value;
    3835        bool in_use;
    3936};
    40 
    41 static inline {
    42         pthread_values *& Back( pthread_values * n ) {
    43                 return (pthread_values *)Back( (Seqable *)n );
    44         }
    45 
    46         pthread_values *& Next( pthread_values * n ) {
    47                 return (pthread_values *)Next( (Colable *)n );
    48         }
    49 }
     37P9_EMBEDDED( pthread_values, dlink(pthread_values) )
    5038
    5139struct pthread_keys {
    5240        bool in_use;
    5341        void (* destructor)( void * );
    54         Sequence(pthread_values) threads;
     42    dlist( pthread_values ) threads;
    5543};
    5644
    … …  
    7866
    7967struct Pthread_kernel_threads{
    80         inline Colable;
     68        inline dlink(Pthread_kernel_threads);
    8169        processor p;
    8270};
    83 
    84 Pthread_kernel_threads *& Next( Pthread_kernel_threads * n ) {
    85         return (Pthread_kernel_threads *)Next( (Colable *)n );
    86 }
    87 
    88 static Stack(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
     71P9_EMBEDDED( Pthread_kernel_threads, dlink(Pthread_kernel_threads) )
     72
     73static dlist(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
    8974static bool cfa_pthreads_kernel_threads_zero = false;   // set to zero ?
    9075static int cfa_pthreads_no_kernel_threads = 1;  // number of kernel threads
    … …  
    231216                                        key = &cfa_pthread_keys[i];
    232217                                        value->in_use = false;
    233                                         remove(key->threads, *value);
     218                                        remove(*value);
     219
    234220                                        // if  a  key  value  has  a  non-NULL  destructor pointer,  and  the  thread  has  a  non-NULL  value associated with that key,
    235221                                        // the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument.
    … …  
    551537
    552538                // Remove key from all threads with a value.
    553                 pthread_values& p;
    554                 Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
    555                 for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
    556                         remove(head, p);
    557                         p.in_use = false;
    558                 }
     539               
     540                // Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
     541                // for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
     542                //      remove(head, p);
     543                //      p.in_use = false;
     544                // }
     545        pthread_values * p = &try_pop_front( cfa_pthread_keys[key].threads );
     546        for ( ; p; ) {           
     547            p->in_use = false;
     548            p = &try_pop_front( cfa_pthread_keys[key].threads );
     549        }
    559550                unlock(key_lock);
    560551                return 0;
    … …  
    585576                if ( ! entry.in_use ) {
    586577                        entry.in_use = true;
    587                         add(cfa_pthread_keys[key].threads, entry);
     578                        insert_last(cfa_pthread_keys[key].threads, entry);
    588579                } // if
    589580                entry.value = (void *)value;
    … …  
    612603        //######################### Parallelism #########################
    613604        void pthread_delete_kernel_threads_() __THROW { // see uMain::~uMain
    614                 Pthread_kernel_threads& p;
    615                 for ( StackIter(Pthread_kernel_threads) iter = {cfa_pthreads_kernel_threads}; iter | p; ) {
    616                         delete(&p);
     605                Pthread_kernel_threads * p = &try_pop_front(cfa_pthreads_kernel_threads);
     606                for ( ; p; ) {
     607            delete(p);
     608                        p = &try_pop_front(cfa_pthreads_kernel_threads);
    617609                } // for
    618610        } // pthread_delete_kernel_threads_
    … …  
    631623                lock( concurrency_lock );
    632624                for ( ; new_level > cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads += 1 ) { // add processors ?
    633                         push(cfa_pthreads_kernel_threads, *new() );
     625                        insert_last(cfa_pthreads_kernel_threads, *new() );
    634626                } // for
    635627                for ( ; new_level < cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads -= 1 ) { // remove processors ?
    636                         delete(&pop(cfa_pthreads_kernel_threads));
     628                        delete(&try_pop_front(cfa_pthreads_kernel_threads));
    637629                } // for
    638630                unlock( concurrency_lock );

  • src/ControlStruct/MultiLevelExit.cpp

    r79b05224 r154672d  
    1010// Created On       : Mon Nov  1 13:48:00 2021
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Mar 28  9:42:00 2022
    13 // Update Count     : 34
     12// Last Modified On : Wed Sep  6 12:00:00 2023
     13// Update Count     : 35
    1414//
    1515
    … …  
    1818#include "AST/Pass.hpp"
    1919#include "AST/Stmt.hpp"
    20 #include "Common/CodeLocationTools.hpp"
    2120#include "LabelGeneratorNew.hpp"
    2221
    … …  
    2625
    2726namespace ControlStruct {
     27
     28namespace {
     29
    2830class Entry {
    2931  public:
    … …  
    3537                bool used = false;
    3638                Target( const Label & label ) : label( label ) {}
    37                 Target() : label( CodeLocation() ) {}
     39                Target() : label( CodeLocation(), "" ) {}
    3840        };
    3941        Target firstTarget;
    … …  
    524526        // if continue is used insert a continue label into the back of the body of the loop
    525527        if ( entry.isContUsed() ) {
    526                 CompoundStmt * new_body = new CompoundStmt( body->location );
    527                 // {}
    528                 new_body->kids.push_back( body );
    529528                // {
    530529                //  body
     530                //  ContinueLabel: ;
    531531                // }
    532                 new_body->kids.push_back(
    533                         labelledNullStmt( body->location, entry.useContExit() ) );
    534                 // {
    535                 //  body
    536                 //  ContinueLabel: {}
    537                 // }
    538                 return new_body;
     532                return new CompoundStmt( body->location, {
     533                        body,
     534                        labelledNullStmt( body->location, entry.useContExit() ),
     535                } );
    539536        }
    540537
    … …  
    620617}
    621618
     619} // namespace
     620
    622621const CompoundStmt * multiLevelExitUpdate(
    623         const CompoundStmt * stmt,
    624         const LabelToStmt & labelTable ) {
     622                const CompoundStmt * stmt, const LabelToStmt & labelTable ) {
    625623        // Must start in the body, so FunctionDecls can be a stopping point.
    626624        Pass<MultiLevelExitCore> visitor( labelTable );
    627         const CompoundStmt * ret = stmt->accept( visitor );
    628         // There are some unset code locations slipping in, possibly by Labels.
    629         const Node * node = localFillCodeLocations( ret->location, ret );
    630         return strict_dynamic_cast<const CompoundStmt *>( node );
    631 }
     625        return stmt->accept( visitor );
     626}
     627
    632628} // namespace ControlStruct
    633629

  • src/ResolvExpr/ResolveTypeof.cc

    r79b05224 r154672d  
    237237            // The designator I want to replace
    238238            const ast::Expr * designator = des->designators.at(0);
    239 
     239            // Stupid flag variable for development, to be removed
     240            bool mutated = false;
    240241            if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
    241242                auto candidates = context.symtab.lookupId(designatorName->name);
    … …  
    244245                if ( candidates.size() != 1 ) return mutDecl;
    245246                auto candidate = candidates.at(0);
    246                 if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
     247                if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type())) {
    247248                    // determine that is an enumInst, swap it with its const value
    248249                    assert( candidates.size() == 1 );
    … …  
    250251                    // Need to iterate over all enum value to find the initializer to swap
    251252                    for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
     253                        const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
    252254                        if ( baseEnum->members.at(m)->name == designatorName->name ) {
    253                             const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
    254255                            assert(mem);
    255                             const ast::ConstantExpr * enumAsInit = ast::ConstantExpr::from_int(newDesination->location, m);
    256                             newDesination->designators.push_back( enumAsInit );
     256                            if ( mem->init ) {
     257                                const ast::SingleInit * memInit = mem->init.as<const ast::SingleInit>();
     258                                ast::Expr * initValue = shallowCopy( memInit->value.get() );
     259                                newDesination->designators.push_back( initValue );
     260                                mutated = true;
     261                            }
     262                            break;
    257263                        }
    258                     }
    259                     if ( newDesination->designators.size() == 0 ) {
    260                         SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value");
    261264                    }
    262265                } else {
    … …  
    266269                newDesination->designators.push_back( des->designators.at(0) );
    267270            }
    268             mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
     271            if ( mutated ) {
     272                mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
     273            }
    269274        }
    270275    }

  • src/ResolvExpr/Resolver.cc

    r79b05224 r154672d  
    988988                        }
    989989                };
     990
     991                struct ResolveDesignators_new final : public ast::WithShortCircuiting {
     992                        ResolveContext& context;
     993                        bool result = false;
     994
     995                        ResolveDesignators_new( ResolveContext& _context ): context{_context} {};
     996
     997                        void previsit( const ast::Node * ) {
     998                                // short circuit if we already know there are designations
     999                                if ( result ) visit_children = false;
     1000                        }
     1001
     1002                        void previsit( const ast::Designation * des ) {
     1003                                if ( result ) visit_children = false;
     1004                                else if ( ! des->designators.empty() ) {
     1005                                        if ( (des->designators.size() == 1) ) {
     1006                                                const ast::Expr * designator = des->designators.at(0);
     1007                                                if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
     1008                                                        auto candidates = context.symtab.lookupId(designatorName->name);
     1009                                                        for ( auto candidate : candidates ) {
     1010                                                                if ( dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
     1011                                                                        result = true;
     1012                                                                        break;
     1013                                                                }
     1014                                                        }
     1015                                                }
     1016                                        }
     1017                                        visit_children = false;
     1018                                }
     1019                        }
     1020                };
    9901021        } // anonymous namespace
    9911022        /// Check if this expression is or includes a deleted expression
    … …  
    15071538                                if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) {
    15081539                                        // constructed objects cannot be designated
    1509                                         // if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
    15101540                                        if ( InitTweak::isDesignated( mutDecl->init ) ) {
    1511                                                 SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
     1541                                                ast::Pass<ResolveDesignators_new> res( context );
     1542                                                maybe_accept( mutDecl->init.get(), res );
     1543                                                if ( !res.core.result ) {
     1544                                                        SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
     1545                                                }
    15121546                                        }
    15131547                                        // constructed objects should not have initializers nested too deeply
Note: See TracChangeset for help on using the changeset viewer.