Changes in / [154672d:79b05224]


Ignore:
Files:
2 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/collections/string.cfa

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

  • libcfa/src/collections/string.hfa

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

  • libcfa/src/collections/string_res.cfa

    r154672d r79b05224  
    637637// Comparisons
    638638
    639 int 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 
    646 bool ?==?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) == 0; }
    647 bool ?!=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) != 0; }
    648 bool ?>? (const string_res &s1, const string_res &s2) { return cmp(s1, s2) >  0; }
    649 bool ?>=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) >= 0; }
    650 bool ?<=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) <= 0; }
    651 bool ?<? (const string_res &s1, const string_res &s2) { return cmp(s1, s2) <  0; }
    652 
    653 int cmp (const string_res &s1, const char* s2) {
    654     string_res s2x = s2;
    655     return cmp(s1, s2x);
    656 }
    657 
    658 bool ?==?(const string_res &s1, const char* s2) { return cmp(s1, s2) == 0; }
    659 bool ?!=?(const string_res &s1, const char* s2) { return cmp(s1, s2) != 0; }
    660 bool ?>? (const string_res &s1, const char* s2) { return cmp(s1, s2) >  0; }
    661 bool ?>=?(const string_res &s1, const char* s2) { return cmp(s1, s2) >= 0; }
    662 bool ?<=?(const string_res &s1, const char* s2) { return cmp(s1, s2) <= 0; }
    663 bool ?<? (const string_res &s1, const char* s2) { return cmp(s1, s2) <  0; }
    664 
    665 int cmp (const char* s1, const string_res & s2) {
    666     string_res s1x = s1;
    667     return cmp(s1x, s2);
    668 }
    669 
    670 bool ?==?(const char* s1, const string_res &s2) { return cmp(s1, s2) == 0; }
    671 bool ?!=?(const char* s1, const string_res &s2) { return cmp(s1, s2) != 0; }
    672 bool ?>? (const char* s1, const string_res &s2) { return cmp(s1, s2) >  0; }
    673 bool ?>=?(const char* s1, const string_res &s2) { return cmp(s1, s2) >= 0; }
    674 bool ?<=?(const char* s1, const string_res &s2) { return cmp(s1, s2) <= 0; }
    675 bool ?<? (const char* s1, const string_res &s2) { return cmp(s1, s2) <  0; }
    676 
     639
     640bool ?==?(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
     644bool ?!=?(const string_res &s1, const string_res &s2) {
     645    return !(s1 == s2);
     646}
     647bool ?==?(const string_res &s, const char* other) {
     648    string_res sother = other;
     649    return s == sother;
     650}
     651bool ?!=?(const string_res &s, const char* other) {
     652    return !(s == other);
     653}
    677654
    678655

  • libcfa/src/collections/string_res.hfa

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

  • libcfa/src/concurrency/io.cfa

    r154672d r79b05224  
    594594                lock( queue.lock __cfaabi_dbg_ctx2 );
    595595                {
    596                         was_empty = queue.queue`isEmpty;
     596                        was_empty = empty(queue.queue);
    597597
    598598                        // Add our request to the list
    599                         insert_last( queue.queue, item );
     599                        add( 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( !this.pending.queue`isEmpty );
     634                /* paranoid */ verify( !empty(this.pending.queue) );
    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( !this.pending.queue`isEmpty ) {
     644                        while( !empty(this.pending.queue) ) {
    645645                                // get first pending allocs
    646646                                __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
    647                                 __pending_alloc & pa = (__pending_alloc&)(this.pending.queue`first);
     647                                __pending_alloc & pa = (__pending_alloc&)head( this.pending.queue );
    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                                 try_pop_front( this.pending.queue );
     653                                drop( 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( !ctx.ext_sq.queue`isEmpty ) {
     729                        while( !empty(ctx.ext_sq.queue) ) {
    730730                                // drop the element from the queue
    731                                 __external_io & ei = (__external_io&)try_pop_front( ctx.ext_sq.queue );
     731                                __external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
    732732
    733733                                // submit it

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

    r154672d r79b05224  
    2424
    2525#include "bits/locks.hfa"
     26#include "bits/queue.hfa"
    2627#include "iofwd.hfa"
    2728#include "kernel/fwd.hfa"
    2829
    2930#if defined(CFA_HAVE_LINUX_IO_URING_H)
     31        #include "bits/sequence.hfa"
    3032        #include "monitor.hfa"
    3133
    … …  
    118120        struct __outstanding_io {
    119121                // intrusive link fields
    120                 inline dlink(__outstanding_io);
     122                inline Colable;
    121123
    122124                // primitive on which to block until the io is processed
    123125                oneshot waitctx;
    124126        };
    125     P9_EMBEDDED( __outstanding_io, dlink(__outstanding_io) )
     127        static inline __outstanding_io *& Next( __outstanding_io * n ) { return (__outstanding_io *)Next( (Colable *)n ); }
    126128
    127129        // queue of operations that are outstanding
    … …  
    132134
    133135                // the actual queue
    134                 dlist(__outstanding_io) queue;
     136                Queue(__outstanding_io) queue;
    135137
    136138                // volatile used to avoid the need for taking the lock if it's empty

  • libcfa/src/concurrency/pthread.cfa

    r154672d r79b05224  
    2020#include <errno.h>
    2121#include "locks.hfa"
     22#include "bits/stack.hfa"
     23#include "bits/sequence.hfa"
     24
    2225
    2326#define check_nonnull(x) asm("": "+rm"(x)); if( x == 0p ) return EINVAL;
    … …  
    3134
    3235struct pthread_values{
    33         inline dlink(pthread_values);
     36        inline Seqable;
    3437        void * value;
    3538        bool in_use;
    3639};
    37 P9_EMBEDDED( pthread_values, dlink(pthread_values) )
     40
     41static 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}
    3850
    3951struct pthread_keys {
    4052        bool in_use;
    4153        void (* destructor)( void * );
    42     dlist( pthread_values ) threads;
     54        Sequence(pthread_values) threads;
    4355};
    4456
    … …  
    6678
    6779struct Pthread_kernel_threads{
    68         inline dlink(Pthread_kernel_threads);
     80        inline Colable;
    6981        processor p;
    7082};
    71 P9_EMBEDDED( Pthread_kernel_threads, dlink(Pthread_kernel_threads) )
    72 
    73 static dlist(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
     83
     84Pthread_kernel_threads *& Next( Pthread_kernel_threads * n ) {
     85        return (Pthread_kernel_threads *)Next( (Colable *)n );
     86}
     87
     88static Stack(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
    7489static bool cfa_pthreads_kernel_threads_zero = false;   // set to zero ?
    7590static int cfa_pthreads_no_kernel_threads = 1;  // number of kernel threads
    … …  
    216231                                        key = &cfa_pthread_keys[i];
    217232                                        value->in_use = false;
    218                                         remove(*value);
    219 
     233                                        remove(key->threads, *value);
    220234                                        // if  a  key  value  has  a  non-NULL  destructor pointer,  and  the  thread  has  a  non-NULL  value associated with that key,
    221235                                        // 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.
    … …  
    537551
    538552                // Remove key from all threads with a value.
    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         }
     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                }
    550559                unlock(key_lock);
    551560                return 0;
    … …  
    576585                if ( ! entry.in_use ) {
    577586                        entry.in_use = true;
    578                         insert_last(cfa_pthread_keys[key].threads, entry);
     587                        add(cfa_pthread_keys[key].threads, entry);
    579588                } // if
    580589                entry.value = (void *)value;
    … …  
    603612        //######################### Parallelism #########################
    604613        void pthread_delete_kernel_threads_() __THROW { // see uMain::~uMain
    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);
     614                Pthread_kernel_threads& p;
     615                for ( StackIter(Pthread_kernel_threads) iter = {cfa_pthreads_kernel_threads}; iter | p; ) {
     616                        delete(&p);
    609617                } // for
    610618        } // pthread_delete_kernel_threads_
    … …  
    623631                lock( concurrency_lock );
    624632                for ( ; new_level > cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads += 1 ) { // add processors ?
    625                         insert_last(cfa_pthreads_kernel_threads, *new() );
     633                        push(cfa_pthreads_kernel_threads, *new() );
    626634                } // for
    627635                for ( ; new_level < cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads -= 1 ) { // remove processors ?
    628                         delete(&try_pop_front(cfa_pthreads_kernel_threads));
     636                        delete(&pop(cfa_pthreads_kernel_threads));
    629637                } // for
    630638                unlock( concurrency_lock );

  • src/ControlStruct/MultiLevelExit.cpp

    r154672d r79b05224  
    1010// Created On       : Mon Nov  1 13:48:00 2021
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Sep  6 12:00:00 2023
    13 // Update Count     : 35
     12// Last Modified On : Mon Mar 28  9:42:00 2022
     13// Update Count     : 34
    1414//
    1515
    … …  
    1818#include "AST/Pass.hpp"
    1919#include "AST/Stmt.hpp"
     20#include "Common/CodeLocationTools.hpp"
    2021#include "LabelGeneratorNew.hpp"
    2122
    … …  
    2526
    2627namespace ControlStruct {
    27 
    28 namespace {
    29 
    3028class Entry {
    3129  public:
    … …  
    3735                bool used = false;
    3836                Target( const Label & label ) : label( label ) {}
    39                 Target() : label( CodeLocation(), "" ) {}
     37                Target() : label( CodeLocation() ) {}
    4038        };
    4139        Target firstTarget;
    … …  
    526524        // if continue is used insert a continue label into the back of the body of the loop
    527525        if ( entry.isContUsed() ) {
     526                CompoundStmt * new_body = new CompoundStmt( body->location );
     527                // {}
     528                new_body->kids.push_back( body );
    528529                // {
    529530                //  body
    530                 //  ContinueLabel: ;
    531531                // }
    532                 return new CompoundStmt( body->location, {
    533                         body,
    534                         labelledNullStmt( body->location, entry.useContExit() ),
    535                 } );
     532                new_body->kids.push_back(
     533                        labelledNullStmt( body->location, entry.useContExit() ) );
     534                // {
     535                //  body
     536                //  ContinueLabel: {}
     537                // }
     538                return new_body;
    536539        }
    537540
    … …  
    617620}
    618621
    619 } // namespace
    620 
    621622const CompoundStmt * multiLevelExitUpdate(
    622                 const CompoundStmt * stmt, const LabelToStmt & labelTable ) {
     623        const CompoundStmt * stmt,
     624        const LabelToStmt & labelTable ) {
    623625        // Must start in the body, so FunctionDecls can be a stopping point.
    624626        Pass<MultiLevelExitCore> visitor( labelTable );
    625         return stmt->accept( visitor );
    626 }
    627 
     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}
    628632} // namespace ControlStruct
    629633

  • src/ResolvExpr/ResolveTypeof.cc

    r154672d r79b05224  
    237237            // The designator I want to replace
    238238            const ast::Expr * designator = des->designators.at(0);
    239             // Stupid flag variable for development, to be removed
    240             bool mutated = false;
     239
    241240            if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
    242241                auto candidates = context.symtab.lookupId(designatorName->name);
    … …  
    245244                if ( candidates.size() != 1 ) return mutDecl;
    246245                auto candidate = candidates.at(0);
    247                 if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type())) {
     246                if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
    248247                    // determine that is an enumInst, swap it with its const value
    249248                    assert( candidates.size() == 1 );
    … …  
    251250                    // Need to iterate over all enum value to find the initializer to swap
    252251                    for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
    253                         const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
    254252                        if ( baseEnum->members.at(m)->name == designatorName->name ) {
     253                            const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
    255254                            assert(mem);
    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;
     255                            const ast::ConstantExpr * enumAsInit = ast::ConstantExpr::from_int(newDesination->location, m);
     256                            newDesination->designators.push_back( enumAsInit );
    263257                        }
     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");
    264261                    }
    265262                } else {
    … …  
    269266                newDesination->designators.push_back( des->designators.at(0) );
    270267            }
    271             if ( mutated ) {
    272                 mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
    273             }
     268            mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
    274269        }
    275270    }

  • src/ResolvExpr/Resolver.cc

    r154672d r79b05224  
    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                 };
    1021990        } // anonymous namespace
    1022991        /// Check if this expression is or includes a deleted expression
    … …  
    15381507                                if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) {
    15391508                                        // 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" );
    15401510                                        if ( InitTweak::isDesignated( mutDecl->init ) ) {
    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                                                 }
     1511                                                SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
    15461512                                        }
    15471513                                        // constructed objects should not have initializers nested too deeply
Note: See TracChangeset for help on using the changeset viewer.