Changes in / [8d96dee:89bef959]


Ignore:
Files:
1 added
4 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/containers/string.cfa

    r8d96dee r89bef959  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 12 15:24:18 2023
    13 // Update Count     : 6
     12// Last Modified On : Mon Aug  7 10:07:26 2023
     13// Update Count     : 2
    1414//
    1515
    … …  
    100100
    101101////////////////////////////////////////////////////////
    102 // Input-Output
    103 
    104 ofstream & ?|?( ofstream & out, const string & this ) {
    105     return out | (*this.inner); // print internal string_res
    106 }
    107 
    108 void ?|?( ofstream & out, const string & this ) {
    109     (ofstream &)(out | (*this.inner)); ends( out );
    110 }
    111 
    112 ifstream & ?|?(ifstream &in, string &this) {
    113     return in | (*this.inner); // read to internal string_res
    114 }
    115 
     102// Output
     103
     104ofstream & ?|?( ofstream & fs, const string & this ) {
     105    return fs | (*this.inner);
     106}
     107
     108void ?|?( ofstream & fs, const string & this ) {
     109    fs | (*this.inner);
     110}
    116111
    117112////////////////////////////////////////////////////////

  • libcfa/src/containers/string.hfa

    r8d96dee r89bef959  
    5555ofstream & ?|?(ofstream &out, const string &s);
    5656void ?|?(ofstream &out, const string &s);
    57 ifstream & ?|?(ifstream &in, string &s);
    5857
    5958// Concatenation

  • libcfa/src/containers/string_res.cfa

    r8d96dee r89bef959  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 12 15:37:47 2023
    13 // Update Count     : 10
     12// Last Modified On : Thu Jun 29 09:29:06 2023
     13// Update Count     : 2
    1414//
    1515
    … …  
    1717#include "string_sharectx.hfa"
    1818#include "stdlib.hfa"
    19 #include <ctype.h>
    2019
    2120// Workaround for observed performance penalty from calling CFA's alloc.
    … …  
    135134        serr | nlOff;
    136135        serr | " lnth:" | lnth | " s:" | (void *)s | ",\"";
    137         for ( i; lnth ) {
     136        for ( int i = 0; i < lnth; i += 1 ) {
    138137            serr | s[i];
    139138        } // for
    … …  
    199198// Output operator
    200199ofstream & ?|?(ofstream &out, const string_res &s) {
    201         // CFA string is NOT null terminated, so print exactly lnth characters in a minimum width of 0.
    202         out | wd( 0, s.Handle.lnth, s.Handle.s ) | nonl;
     200    // Store auto-newline state so it can be restored
     201    bool anl = getANL$(out);
     202    nlOff(out);
     203    for (size_t i = 0; i < s.Handle.lnth; i++) {
     204        out | s[i];
     205    }
     206    out | sepVal;
     207    // Re-apply newlines after done, for chaining version
     208    if (anl) nlOn(out);
    203209    return out;
    204210}
    205211
    206212void ?|?(ofstream &out, const string_res &s) {
    207         (ofstream &)(out | s); ends( out );
    208 }
    209 
    210 // Input operator
    211 ifstream & ?|?(ifstream &in, string_res &s) {
    212 
    213     // Reading into a temp before assigning to s is near zero overhead in typical cases because of sharing.
    214     // If s is a substring of something larger, simple assignment takes care of that case correctly.
    215     // But directly reading a variable amount of text into the middle of a larger context is not practical.
    216     string_res temp;
    217 
    218     // Read in chunks.  Often, one chunk is enough.  Keep the string that accumulates chunks last in the heap,
    219     // so available room is rest of heap.  When a chunk fills the heap, force growth then take the next chunk.
    220     for (;;) {
    221         // Append dummy content to temp, forcing expansion when applicable (occurs always on subsequent loops)
    222         // length 2 ensures room for at least one real char, plus scanf/pipe-cstr's null terminator
    223         temp += "--";
    224         assert( temp.Handle.ulink->EndVbyte == temp.Handle.s + temp.Handle.lnth );    // last in heap
    225 
    226         // reset, to overwrite the appended "--"
    227         temp.Handle.lnth -= 2;
    228         temp.Handle.ulink->EndVbyte -= 2;
    229 
    230         // rest of heap, less 1 byte for null terminator, is available to read into
    231         int lenReadable = (char*)temp.Handle.ulink->ExtVbyte - temp.Handle.ulink->EndVbyte - 1;
    232         assert (lenReadable >= 1);
    233 
    234         // get bytes
    235         in | wdi( lenReadable, temp.Handle.ulink->EndVbyte );
    236         int lenWasRead = strlen(temp.Handle.ulink->EndVbyte);
    237 
    238         // update metadata
    239         temp.Handle.lnth += lenWasRead;
    240         temp.Handle.ulink->EndVbyte += lenWasRead;
    241 
    242       if (lenWasRead < lenReadable) break;
    243     }
    244 
    245     s = temp;
    246     return in;
    247 }
    248 
     213    // Store auto-newline state so it can be restored
     214    bool anl = getANL$(out);
     215    if( s.Handle.lnth == 0 ) {
     216        sout | "";
     217    } else {
     218        nlOff(out);
     219        for (size_t i = 0; i < s.Handle.lnth; i++) {
     220            // Need to re-apply on the last output operator, for whole-statement version
     221            if (anl && i == s.Handle.lnth-1) nlOn(out);
     222            out | s[i];
     223        }
     224    }
     225}
    249226
    250227// Empty constructor
    … …  
    361338    // adjust all substring string and handle locations, and check if any substring strings are outside the new base string
    362339    char *limit = resultSesStart + resultSesLnth;
    363     for ( string_res * p = this.shareEditSet_next; p != &this; p = p->shareEditSet_next ) {
     340    for (string_res * p = this.shareEditSet_next; p != &this; p = p->shareEditSet_next) {
    364341        verify (p->Handle.s >= beforeBegin);
    365342        if ( p->Handle.s >= afterBegin ) {
    … …  
    414391}
    415392
    416 // traverse the share-edit set (SES) to recover the range of a base string to which `this` belongs
    417 static void locateInShareEditSet( string_res &this, string_res *&shareEditSetStartPeer, string_res *&shareEditSetEndPeer ) {
    418     shareEditSetStartPeer = & this;
    419     shareEditSetEndPeer = & this;
     393static string_res & assign_(string_res &this, const char* buffer, size_t bsize, const string_res & valSrc) {
     394
     395    // traverse the incumbent share-edit set (SES) to recover the range of a base string to which `this` belongs
     396    string_res * shareEditSetStartPeer = & this;
     397    string_res * shareEditSetEndPeer = & this;
    420398    for (string_res * editPeer = this.shareEditSet_next; editPeer != &this; editPeer = editPeer->shareEditSet_next) {
    421399        if ( editPeer->Handle.s < shareEditSetStartPeer->Handle.s ) {
    … …  
    426404        }
    427405    }
    428 }
    429 
    430 static string_res & assign_(string_res &this, const char* buffer, size_t bsize, const string_res & valSrc) {
    431 
    432     string_res * shareEditSetStartPeer;
    433     string_res * shareEditSetEndPeer;
    434     locateInShareEditSet( this, shareEditSetStartPeer, shareEditSetEndPeer );
    435406
    436407    verify( shareEditSetEndPeer->Handle.s >= shareEditSetStartPeer->Handle.s );
    … …  
    618589
    619590bool contains(const string_res &s, char ch) {
    620     for ( i; size(s) ) {
     591    for (i; size(s)) {
    621592        if (s[i] == ch) return true;
    622593    }
    … …  
    672643    }
    673644
    674     for ( i; fromPos ~ s.Handle.lnth ) {
     645    for (size_t i = fromPos; i < s.Handle.lnth; i++) {
    675646        size_t remaining = s.Handle.lnth - i;
    676647        // Never going to find the search string if the remaining string is
    … …  
    681652
    682653        bool matched = true;
    683         for ( j; searchsize ) {
     654        for (size_t j = 0; j < searchsize; j++) {
    684655            if (search[j] != s.Handle.s[i + j]) {
    685656                matched = false;
    … …  
    769740
    770741int exclude(const string_res &s, const charclass_res &mask) {
    771     for ( i; size(s) ) {
     742    for (int i = 0; i < size(s); i++) {
    772743        if ( test(mask, s[i]) ) return i;
    773744    }
    … …  
    776747
    777748int include(const string_res &s, const charclass_res &mask) {
    778     for ( i; size(s) ) {
     749    for (int i = 0; i < size(s); i++) {
    779750        if ( ! test(mask, s[i]) ) return i;
    780751    }
    … …  
    804775                for ( HandleNode *ni = HeaderPtr->flink; ni != HeaderPtr; ni = ni->flink ) {
    805776                        serr | "\tnode:" | ni | " lnth:" | ni->lnth | " s:" | (void *)ni->s | ",\"";
    806                         for ( i; ni->lnth ) {
     777                        for ( int i = 0; i < ni->lnth; i += 1 ) {
    807778                                serr | ni->s[i];
    808779                        } // for
    … …  
    910881        for ( HandleNode *n = HeaderPtr->flink; n != HeaderPtr; n = n->flink ) {
    911882            serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
    912             for ( i; n->lnth ) {
    913                         serr | n->s[i];
     883            for ( int i = 0; i < n->lnth; i += 1 ) {
     884                serr | n->s[i];
    914885            } // for
    915886            serr | "\" flink:" | n->flink | " blink:" | n->blink | nl;
    … …  
    989960    EndVbyte = StartVbyte;
    990961    h = Header.flink;                                   // ignore header node
    991     for () {
     962    for (;;) {
    992963                memmove( EndVbyte, h->s, h->lnth );
    993964                obase = h->s;
    … …  
    1000971                // check if any substrings are allocated within a string
    1001972               
    1002                 for () {
     973                for (;;) {
    1003974                        if ( h == &Header ) break;                      // end of header list ?
    1004975                        if ( h->s >= limit ) break;                     // outside of current string ?
    … …  
    10301001                        serr | nlOff;
    10311002                        serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
    1032                         for ( i; n->lnth ) {
     1003                        for ( int i = 0; i < n->lnth; i += 1 ) {
    10331004                                serr | n->s[i];
    10341005                        } // for
    … …  
    10651036                        serr | nlOff;
    10661037                        serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
    1067                         for ( i; n->lnth ) {
     1038                        for ( int i = 0; i < n->lnth; i += 1 ) {
    10681039                                serr | n->s[i];
    10691040                        } // for

  • libcfa/src/containers/string_res.hfa

    r8d96dee r89bef959  
    99// Author           : Michael L. Brooks
    1010// Created On       : Fri Sep 03 11:00:00 2021
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 12 15:45:47 2023
    13 // Update Count     : 2
     11// Last Modified By : Michael L. Brooks
     12// Last Modified On : Fri Sep 03 11:00:00 2021
     13// Update Count     : 1
    1414//
    1515
    … …  
    3030    VbyteHeap *ulink;                   // upward link
    3131
    32     char *s;                                                    // pointer to byte string
     32    char *s;                                            // pointer to byte string
    3333    unsigned int lnth;                                  // length of byte string
    3434}; // HandleNode
    … …  
    101101ofstream & ?|?(ofstream &out, const string_res &s);
    102102void ?|?(ofstream &out, const string_res &s);
    103 ifstream & ?|?(ifstream &in, string_res &s);
    104103
    105104// Concatenation

  • src/ControlStruct/ExceptDeclNew.cpp

    r8d96dee r89bef959  
    242242}
    243243
    244 ast::ObjectDecl * createExternVTable(
     244static ast::ObjectDecl * createExternVTable(
    245245                CodeLocation const & location,
    246246                std::string const & exceptionName,
    … …  
    453453        std::string const & tableName = decl->name;
    454454
    455         ast::ObjectDecl * retDecl;
     455    ast::ObjectDecl * retDecl;
    456456        if ( decl->storage.is_extern ) {
    457457                // Unique type-ids are only needed for polymorphic instances.
    … …  
    475475        }
    476476
    477         for ( ast::ptr<ast::Attribute> const & attr : decl->attributes ) {
    478                 retDecl->attributes.push_back( attr );
    479         }
    480 
    481         return retDecl;
     477    for ( ast::ptr<ast::Attribute> const & attr : decl->attributes ) {
     478        retDecl->attributes.push_back( attr );
     479    }
     480
     481    return retDecl;
    482482}
    483483
    … …  
    485485        ast::StructInstType const * postvisit( ast::VTableType const * type ) {
    486486                auto inst = type->base.as<ast::BaseInstType>();
    487 
     487       
    488488                std::string vtableName = Virtual::vtableTypeName( inst->name );
    489489

  • src/Parser/StatementNode.cc

    r8d96dee r89bef959  
    1010// Author           : Rodolfo G. Esteves
    1111// Created On       : Sat May 16 14:59:41 2015
    12 // Last Modified By : Peter A. Buhr
    13 // Last Modified On : Fri Aug 11 11:44:15 2023
    14 // Update Count     : 429
     12// Last Modified By : Andrew Beach
     13// Last Modified On : Tue Apr 11 10:16:00 2023
     14// Update Count     : 428
    1515//
    1616
    … …  
    374374}
    375375
     376ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
     377        ast::WhenClause * clause = new ast::WhenClause( loc );
     378        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
     379        clause->stmt = maybeMoveBuild( stmt );
     380        clause->target = maybeMoveBuild( timeout );
     381        return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::TIMEOUT, clause );
     382}
     383
    376384ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
    377385        ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );

  • src/Parser/StatementNode.h

    r8d96dee r89bef959  
    99// Author           : Andrew Beach
    1010// Created On       : Wed Apr  5 11:42:00 2023
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug 11 11:44:07 2023
    13 // Update Count     : 2
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tue Apr 11  9:43:00 2023
     13// Update Count     : 1
    1414//
    1515
    … …  
    102102ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation &, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt );
    103103ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation &, ExpressionNode * when, StatementNode * stmt );
     104ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation &, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt );
    104105ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation &, ast::WaitUntilStmt::ClauseNode * root );
    105106ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );

  • src/Parser/parser.yy

    r8d96dee r89bef959  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 18 22:51:30 2023
    13 // Update Count     : 6391
     12// Last Modified On : Wed Jul 12 23:06:44 2023
     13// Update Count     : 6389
    1414//
    1515
    … …  
    17081708        | wor_waituntil_clause wor when_clause_opt ELSE statement
    17091709                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
     1710        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
     1711                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
     1712        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
     1713        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rule
     1714                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
     1715        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
     1716                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
     1717                                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR,
     1718                                        build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ),
     1719                                        build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
    17101720        ;
    17111721
    17121722waituntil_statement:
    17131723        wor_waituntil_clause                                                            %prec THEN
    1714                 { $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) ); }
     1724                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
     1725                {
     1726                        $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
     1727                        // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
     1728                }
    17151729        ;
    17161730

  • tests/io/.expect/manipulatorsOutput2.arm64.txt

    r8d96dee r89bef959  
    440 033 033 033 033
    550345 0177745 037777777745 01777777777777777777745
    6 0x0 0x1b 0x1b 0x1b 0x1b
     60 0x1b 0x1b 0x1b 0x1b
    770xe5 0xffe5 0xffffffe5 0xffffffffffffffe5
    8 0x0p+0 0x1.b8p+4 0x1.b8p+4 0x1.b8p+4
     80x0p+0. 0x1.b8p+4 0x1.b8p+4 0x1.b8p+4
    99-0x1.b8p+4 -0x1.b8p+4 -0x1.b8p+4
    10100.000000e+00 2.750000e+01 -2.750000e+01

  • tests/io/.expect/manipulatorsOutput2.x86.txt

    r8d96dee r89bef959  
    440 033 033 033 033
    550345 0177745 037777777745 037777777745
    6 0x0 0x1b 0x1b 0x1b 0x1b
     60 0x1b 0x1b 0x1b 0x1b
    770xe5 0xffe5 0xffffffe5 0xffffffe5
    8 0x0p+0 0x1.b8p+4 0x1.b8p+4 0xd.cp+1
     80x0p+0. 0x1.b8p+4 0x1.b8p+4 0xd.cp+1
    99-0x1.b8p+4 -0x1.b8p+4 -0xd.cp+1
    10100.000000e+00 2.750000e+01 -2.750000e+01

  • tests/io/.expect/manipulatorsOutput3.arm64.txt

    r8d96dee r89bef959  
    246246-1                   0xffffffffffffffffffffffffffffffff 03777777777777777777777777777777777777777777
    2472470b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
    248 +0                   0x0                  0                   
     248+0                   0                    0                   
    2492490b0                 
    250250+1                   0x1                  01                 
Note: See TracChangeset for help on using the changeset viewer.