Changeset 8a9a3ab for libcfa/src


Ignore:
Timestamp:
Sep 1, 2023, 3:54:42 PM (9 months ago)
Author:
caparsons <caparson@…>
Branches:
master
Children:
4b30318b
Parents:
4269d1b (diff), 4c0fa03 (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

Location:
libcfa/src
Files:
12 edited
18 moved

Legend:

Unmodified
Added
Removed

  • libcfa/src/Makefile.am

    r4269d1b r8a9a3ab  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Mon Aug 14 17:10:51 2023
    14 ## Update Count     : 262
     13## Last Modified On : Wed Aug 30 21:22:45 2023
     14## Update Count     : 263
    1515###############################################################################
    1616
    … …  
    5252        bits/algorithm.hfa \
    5353        bits/align.hfa \
    54         bits/containers.hfa \
     54        bits/collections.hfa \
    5555        bits/debug.hfa \
    5656        bits/defs.hfa \
    … …  
    6363        concurrency/iofwd.hfa \
    6464        concurrency/barrier.hfa \
    65         containers/array.hfa \
    66         containers/list.hfa \
    67         containers/lockfree.hfa \
    68         containers/string_sharectx.hfa \
    69         containers/vector2.hfa \
     65        collections/array.hfa \
     66        collections/list.hfa \
     67        collections/lockfree.hfa \
     68        collections/string_sharectx.hfa \
     69        collections/vector2.hfa \
    7070        vec/vec.hfa \
    7171        vec/vec2.hfa \
    … …  
    8989        bits/weakso_locks.hfa \
    9090        algorithms/range_iterator.hfa \
    91         containers/maybe.hfa \
    92         containers/pair.hfa \
    93         containers/result.hfa \
    94         containers/string.hfa \
    95         containers/string_res.hfa \
    96         containers/vector.hfa \
     91        collections/maybe.hfa \
     92        collections/pair.hfa \
     93        collections/result.hfa \
     94        collections/string.hfa \
     95        collections/string_res.hfa \
     96        collections/vector.hfa \
    9797        device/cpu.hfa
    9898

  • libcfa/src/bits/collections.hfa

    r4269d1b r8a9a3ab  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // bits/containers.hfa -- Intrusive generic containers.hfa
     7// bits/collections.hfa -- Intrusive generic collections
    88//
    99// Author           : Thierry Delisle
    1010// Created On       : Tue Oct 31 16:38:50 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  2 11:33:08 2023
    13 // Update Count     : 29
     12// Last Modified On : Wed Aug 30 21:26:39 2023
     13// Update Count     : 30
    1414
    1515#pragma once

  • libcfa/src/bits/weakso_locks.hfa

    r4269d1b r8a9a3ab  
    2020#include "bits/locks.hfa"
    2121#include "bits/sequence.hfa"
    22 #include "bits/containers.hfa"
    23 #include "containers/list.hfa"
     22#include "bits/collections.hfa"
     23#include "collections/list.hfa"
    2424
    2525struct select_node;

  • libcfa/src/collections/maybe.cfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Wed May 24 15:40:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 17 11:22:03 2019
    13 // Update Count     : 3
     12// Last Modified On : Wed Aug 30 21:26:55 2023
     13// Update Count     : 4
    1414//
    1515
    16 #include <containers/maybe.hfa>
     16#include <collections/maybe.hfa>
    1717#include <assert.h>
    1818

  • libcfa/src/collections/pair.cfa

    r4269d1b r8a9a3ab  
    66// Author           : Aaron Moss
    77// Created On       : Wed Apr 12 15:32:00 2017
    8 // Last Modified By : Aaron Moss
    9 // Last Modified On : Wed Apr 12 15:32:00 2017
    10 // Update Count     : 1
     8// Last Modified By : Peter A. Buhr
     9// Last Modified On : Wed Aug 30 21:27:12 2023
     10// Update Count     : 2
    1111//
    1212
    13 #include <containers/pair.hfa>
     13#include <collections/pair.hfa>
    1414
    1515forall(R, S

  • libcfa/src/collections/result.cfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Wed May 24 15:40:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 17 11:24:04 2019
    13 // Update Count     : 3
     12// Last Modified On : Wed Aug 30 21:27:22 2023
     13// Update Count     : 4
    1414//
    1515
    16 #include <containers/result.hfa>
     16#include <collections/result.hfa>
    1717#include <assert.h>
    1818

  • libcfa/src/collections/string.cfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 28 19:00:45 2023
    13 // Update Count     : 146
     12// Last Modified On : Thu Aug 31 13:20:41 2023
     13// Update Count     : 161
    1414//
    1515
    … …  
    118118}
    119119
    120 static void readstr( ifstream & is, _Istream_str f, char fmtstr[], char cstr[] ) {
    121         int check = f.rwd - 1;
    122 
    123         if ( ! f.flags.rwd ) cstr[check] = '\0';                        // insert sentinel
    124         int len = fmt( is, fmtstr, cstr );
    125         // fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, cstr[check], cstr );
    126 
    127         if ( ! f.flags.rwd && cstr[check] != '\0' )                     // sentinel overwritten ?
    128                 throw (cstring_length){ &cstring_length_vt };
    129 
    130         if ( f.flags.delimit ) {                                                        // getline ?
    131                 if ( len == 0 ) cstr[0] = '\0';                                 // empty read => argument unchanged => set empty
    132                 if ( ! eof( is ) ) fmt( is, "%*c" );                    // ignore delimiter
    133         } //if
    134 } // readstr
    135 
    136120ifstream & ?|?( ifstream & is, _Istream_str f ) {
    137121        // skip, same as for char *
    138122        if ( ! &f.s ) {
    139123                // fprintf( stderr,  "skip %s %d\n", f.scanset, f.wd );
    140                 if ( f.rwd == -1 ) fmt( is, f.scanset, "" ); // no input arguments
    141                 else for ( f.rwd ) fmt( is, "%*c" );
     124                if ( f.wd == -1 ) fmt( is, f.scanset, "" ); // no input arguments
     125                else for ( f.wd ) fmt( is, "%*c" );
    142126                return is;
    143127        } // if
    144128
    145         enum { gwd = 16 + 2, wd = gwd - 1 };                            // guarded and unguarded width
     129        // .---------------,
     130        // | | | | |...|0|0| check and guard
     131        // `---------------'
     132        enum { gwd = 128 + 2, wd = gwd - 1 };                           // guarded and unguarded width
    146133        char cstr[gwd];                                                                         // read in chunks
    147         bool cont = false;;
    148 
    149         if ( f.rwd == -1 ) f.rwd = wd;
    150         const char * scanset = f.scanset;;
    151         if ( f.flags.delimit ) scanset = f.delimit;                     // getline ?
    152 
    153         size_t len = 0;
    154         if ( scanset ) len = strlen( scanset );
    155         char fmtstr[len + 16];
    156         int start = 1;
    157         fmtstr[0] = '%';
    158         if ( f.flags.ignore ) { fmtstr[1] = '*'; start += 1; }
    159         if ( f.rwd != -1 ) { start += sprintf( &fmtstr[start], "%d", f.rwd ); }
    160 
    161         if ( ! scanset ) {
    162                 // %s, %*s, %ws, %*ws
    163                 fmtstr[start] = 's'; fmtstr[start + 1] = '\0';
    164                 // printf( "cstr %s\n", fmtstr );
    165         } else {
    166                 // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
    167                 // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
    168                 fmtstr[start] = '['; start += 1;
    169                 if ( f.flags.inex ) { fmtstr[start] = '^'; start += 1; }
    170                 strcpy( &fmtstr[start], scanset );                              // copy includes '\0'
    171                 len += start;
    172                 fmtstr[len] = ']'; fmtstr[len + 1] = '\0';
    173                 // printf( "incl/excl %s\n", fmtstr );
    174         } // if
     134        bool cont = false;
     135
     136        if ( f.wd == -1 ) f.wd = wd;
     137        _Istream_Cstr cfmt = { cstr, (_Istream_str_base)f };
    175138
    176139        cstr[wd] = '\0';                                                                        // guard null terminate string
    177140        try {
    178                 readstr( is, f, fmtstr, cstr );
     141                is | cfmt;
    179142        } catch( cstring_length * ) {
    180143                cont = true;
    … …  
    185148                cont = false;
    186149                try {
    187                         readstr( is, f, fmtstr, cstr );
     150                        is | cfmt;
    188151                } catch( cstring_length * ) {
    189152                        cont = true;                                                            // continue not allowed
    … …  
    199162}
    200163
    201 // void getline( ifstream & in, string & str, const char delimit = '\n' ) {
    202 //      // .---------------,
    203 //      // | | | | |...|0|0| check and guard
    204 //      // `---------------'
    205 //      enum { gwd = 128 + 2, wd = gwd - 1 };                           // guarded and unguarded width
    206 //      char cstr[gwd];                                                                         // read in chunks
    207 //      bool cont = false;;
    208 
    209 //      cstr[wd] = '\0';                                                                        // guard null terminate string
    210 //      try {
    211 //              in | getline( wdi( wd, cstr ), delimit );               // must have room for string terminator
    212 //              if ( eof( in  ) ) return;                                               // do not change argument
    213 //      } catch( cstring_length * ) {
    214 //              cont = true;
    215 //      } finally {
    216 //              str = cstr;                                                                             // ok to initialize string
    217 //      } // try
    218 //      for ( ; cont; )  {                                                                      // overflow read ?
    219 //              cont = false;
    220 //              try {
    221 //                      in | getline( wdi( wd, cstr ), delimit );       // must have room for string terminator
    222 //                      if ( eof( in  ) ) return;
    223 //              } catch( cstring_length * ) {
    224 //                      cont = true;                                                            // continue not allowed
    225 //              } finally {
    226 //                      str += cstr;                                                            // build string chunk at a time
    227 //              } // try
    228 //      } // for
    229 // }
    230 
    231164////////////////////////////////////////////////////////
    232165// Slicing

  • libcfa/src/collections/string.hfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Fri Sep 03 11:00:00 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 28 18:32:59 2023
    13 // Update Count     : 40
     12// Last Modified On : Thu Aug 31 11:47:27 2023
     13// Update Count     : 49
    1414//
    1515
    … …  
    5858void ?|?( ifstream & in, string & this );
    5959
    60 
    6160struct _Istream_str {
    6261        string & s;
    63         union {
    64                 const char * scanset;
    65                 char delimit[2];
    66         };
    67         int rwd;                                                                                        // read width
    68         union {
    69                 unsigned char all;
    70                 struct {
    71                         unsigned char ignore:1;                                         // do not change input argument
    72                         unsigned char inex:1;                                           // include/exclude characters in scanset
    73                         unsigned char delimit:1;                                        // delimit character
    74                         unsigned char rwd:1;                                            // read width
    75                 } flags;
    76         };
     62        inline _Istream_str_base;
    7763}; // _Istream_str
    7864
    7965static inline {
    8066        // read width does not include null terminator
    81         _Istream_str wdi( unsigned int rwd, string & s ) { return (_Istream_str)@{ s, {0p}, rwd, {.flags.rwd : true} }; }
    82         _Istream_str skip( const char scanset[] ) { return (_Istream_str)@{ *0p, {scanset}, -1, {.all : 0} }; }
    83         _Istream_str skip( unsigned int wd ) { return (_Istream_str)@{ *0p, {0p}, wd, {.all : 0} }; }
     67        _Istream_str wdi( unsigned int rwd, string & s ) { return (_Istream_str)@{ s, {{0p}, rwd, {.flags.rwd : true}} }; }
     68        _Istream_str skip( const char scanset[] ) { return (_Istream_str)@{ *0p, {{scanset}, -1, {.all : 0}} }; }
     69        _Istream_str skip( unsigned int wd ) { return (_Istream_str)@{ *0p, {{0p}, wd, {.all : 0}} }; }
    8470        _Istream_str getline( string & s, const char delimit = '\n' ) {
    85                 return (_Istream_str)@{ s, {.delimit : { delimit, '\0' } }, -1, {.flags.delimit : true, .flags.inex : true} };
     71                return (_Istream_str)@{ s, {{.delimit : { delimit, '\0' } }, -1, {.flags.delimit : true, .flags.inex : true}} };
    8672        }
    8773        _Istream_str & getline( _Istream_str & fmt, const char delimit = '\n' ) {
    8874                fmt.delimit[0] = delimit; fmt.delimit[1] = '\0'; fmt.flags.delimit = true; fmt.flags.inex = true; return fmt;
    8975        }
    90         _Istream_str incl( const char scanset[], string & s ) { return (_Istream_str)@{ s, {scanset}, -1, {.flags.inex : false} }; }
     76        _Istream_str incl( const char scanset[], string & s ) { return (_Istream_str)@{ s, {{scanset}, -1, {.flags.inex : false}} }; }
    9177        _Istream_str & incl( const char scanset[], _Istream_str & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
    92         _Istream_str excl( const char scanset[], string & s ) { return (_Istream_str)@{ s, {scanset}, -1, {.flags.inex : true} }; }
     78        _Istream_str excl( const char scanset[], string & s ) { return (_Istream_str)@{ s, {{scanset}, -1, {.flags.inex : true}} }; }
    9379        _Istream_str & excl( const char scanset[], _Istream_str & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
    94         _Istream_str ignore( string & s ) { return (_Istream_str)@{ s, {0p}, -1, {.flags.ignore : true} }; }
     80        _Istream_str ignore( string & s ) { return (_Istream_str)@{ s, {{0p}, -1, {.flags.ignore : true}} }; }
    9581        _Istream_str & ignore( _Istream_str & fmt ) { fmt.flags.ignore = true; return fmt; }
    9682} // distribution
    9783ifstream & ?|?( ifstream & is, _Istream_str f );
    9884void ?|?( ifstream & is, _Istream_str t );
    99 void getline( ifstream & in, string & this, const char delimit = '\n' );
    10085
    10186// Concatenation

  • libcfa/src/collections/vector.cfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Tue Jul  5 18:07:52 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  5 18:08:31 2016
    13 // Update Count     : 2
     12// Last Modified On : Wed Aug 30 21:27:31 2023
     13// Update Count     : 3
    1414//
    1515
    16 #include <containers/vector.hfa>
     16#include <collections/vector.hfa>
    1717
    1818#include <stdlib.hfa>

  • libcfa/src/concurrency/alarm.hfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Fri Jun 2 11:31:25 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 26 16:25:41 2018
    13 // Update Count     : 11
     12// Last Modified On : Wed Aug 30 21:27:40 2023
     13// Update Count     : 12
    1414//
    1515
    … …  
    2323#include "time.hfa"
    2424
    25 #include "containers/list.hfa"
     25#include "collections/list.hfa"
    2626
    2727struct thread$;

  • libcfa/src/concurrency/invoke.h

    r4269d1b r8a9a3ab  
    1010// Created On       : Tue Jan 17 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Mar 14 13:39:31 2023
    13 // Update Count     : 59
     12// Last Modified On : Wed Aug 30 21:27:51 2023
     13// Update Count     : 60
    1414//
    1515
    1616// No not use #pragma once was this file is included twice in some places. It has its own guard system.
    1717
    18 #include "bits/containers.hfa"
     18#include "bits/collections.hfa"
    1919#include "bits/defs.hfa"
    2020#include "bits/locks.hfa"
    … …  
    2323
    2424#ifdef __cforall
    25 #include "containers/list.hfa"
     25#include "collections/list.hfa"
    2626extern "C" {
    2727#endif

  • libcfa/src/concurrency/kernel.hfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:29:26 2020
    13 // Update Count     : 22
     12// Last Modified On : Wed Aug 30 21:28:46 2023
     13// Update Count     : 23
    1414//
    1515
    … …  
    2020#include "coroutine.hfa"
    2121
    22 #include "containers/list.hfa"
     22#include "collections/list.hfa"
    2323
    2424extern "C" {

  • libcfa/src/concurrency/locks.hfa

    r4269d1b r8a9a3ab  
    2121
    2222#include "bits/weakso_locks.hfa"
    23 #include "containers/lockfree.hfa"
    24 #include "containers/list.hfa"
     23#include "collections/lockfree.hfa"
     24#include "collections/list.hfa"
    2525
    2626#include "limits.hfa"

  • libcfa/src/concurrency/once.hfa

    r4269d1b r8a9a3ab  
    1616#pragma once
    1717
    18 #include "containers/lockfree.hfa"
     18#include "collections/lockfree.hfa"
    1919#include "kernel/fwd.hfa"
    2020

  • libcfa/src/concurrency/select.hfa

    r4269d1b r8a9a3ab  
    1717#pragma once
    1818
    19 #include "containers/list.hfa"
     19#include "collections/list.hfa"
    2020#include "alarm.hfa"
    2121#include "kernel.hfa"

  • libcfa/src/executor.baseline.txt

    r4269d1b r8a9a3ab  
    55
    66#include <thread.hfa>
    7 #include <containers/list.hfa>
     7#include <collections/list.hfa>
    88
    99forall( T & | $dlistable(T, T) ) {

  • libcfa/src/executor.cfa

    r4269d1b r8a9a3ab  
    55
    66#include <thread.hfa>
    7 #include <containers/list.hfa>
     7#include <collections/list.hfa>
    88
    99forall( T &, TLink& = dlink(T) | embedded(T, TLink, dlink(T)) ) {

  • libcfa/src/iostream.cfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 28 13:36:16 2023
    13 // Update Count     : 1527
     12// Last Modified On : Thu Aug 31 11:27:56 2023
     13// Update Count     : 1545
    1414//
    1515
    … …  
    971971                } // if
    972972
    973                 int check = f.wd - 1;
    974                 const char * scanset = f.scanset;;
     973                const char * scanset = f.scanset;
    975974                if ( f.flags.delimit ) scanset = f.delimit;             // getline ?
    976 
    977                 // getline
    978                 // if ( f.flags.delimit ) {
    979                 //      enum { size = 32 };
    980                 //      char fmtstr[size];
    981                 //      snprintf( fmtstr, size, "%%%d[^%c]s", f.wd, f.delimit );
    982                 //      if ( ! f.flags.rwd ) f.s[check] = '\0';         // insert sentinel
    983                 //      int len = fmt( is, fmtstr, f.s );                       // read upto delimiter
    984                 //      if ( ! f.flags.rwd && f.s[check] != '\0' )      // sentinel overwritten ?
    985                 //              throw (cstring_length){ &cstring_length_vt };
    986                 //      if ( len == 0 ) f.s[0] = '\0';                          // empty read => argument unchanged => set empty
    987                 //      // fprintf( stderr, "getline %s %s %d %d %d '%c'\n", fmtstr, f.s, len, f.wd, check, f.s[check] );
    988                 //      if ( ! eof( is ) ) fmt( is, "%*c" );            // ignore delimiter
    989                 //      return is;
    990                 // } // if
    991975
    992976                size_t len = 0;
    … …  
    1013997                } // if
    1014998
     999                int check = f.wd - 1;
    10151000                if ( ! f.flags.rwd ) f.s[check] = '\0';                 // insert sentinel
    10161001                len = fmt( is, fmtstr, f.s );
    10171002                //fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, f.s[check], f.s );
     1003
    10181004                if ( ! f.flags.rwd && f.s[check] != '\0' )              // sentinel overwritten ?
    10191005                        throw (cstring_length){ &cstring_length_vt };
    10201006
    10211007                if ( f.flags.delimit ) {                                                // getline ?
    1022                         if ( len == 0 ) f.s[0] = '\0';                          // empty read => argument unchanged => set empty
    1023                         if ( ! eof( is ) ) fmt( is, "%*c" );            // ignore delimiter
     1008                        if ( len == 0 ) f.s[0] = '\0';                          // empty read => argument unchanged => set empty
     1009                        if ( ! eof( is ) ) fmt( is, "%*c" );            // ignore delimiter
    10241010                } //if
    10251011                return is;

  • libcfa/src/iostream.hfa

    r4269d1b r8a9a3ab  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug 25 14:55:06 2023
    13 // Update Count     : 535
     12// Last Modified On : Thu Aug 31 10:55:35 2023
     13// Update Count     : 544
    1414//
    1515
    … …  
    406406// *********************************** manipulators ***********************************
    407407
    408 struct _Istream_Cstr {
    409         char * s;
     408struct _Istream_str_base {
    410409        union {
    411410                const char * scanset;
    … …  
    422421                } flags;
    423422        };
     423}; // _Istream_str_base
     424
     425struct _Istream_Cstr {
     426        char * s;
     427        inline _Istream_str_base;
    424428}; // _Istream_Cstr
    425429
    426430static inline {
    427431        // width must include room for null terminator
    428         _Istream_Cstr wdi( unsigned int wd, char s[] ) { return (_Istream_Cstr)@{ s, {0p}, wd, {.all : 0} }; }
     432        _Istream_Cstr wdi( unsigned int wd, char s[] ) { return (_Istream_Cstr)@{ s, { {0p}, wd, {.all : 0} } }; }
    429433        // read width does not include null terminator
    430434        _Istream_Cstr wdi( unsigned int wd, unsigned int rwd, char s[] ) {
    431435                if ( wd <= rwd ) throw (cstring_length){ &cstring_length_vt };
    432                 return (_Istream_Cstr)@{ s, {0p}, rwd, {.flags.rwd : true} };
     436                return (_Istream_Cstr)@{ s, { {0p}, rwd, {.flags.rwd : true} } };
    433437        }
    434         _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr)@{ 0p, {scanset}, -1, {.all : 0} }; }
    435         _Istream_Cstr skip( unsigned int wd ) { return (_Istream_Cstr)@{ 0p, {0p}, wd, {.all : 0} }; }
     438        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr)@{ 0p, { {scanset}, -1, {.all : 0} } }; }
     439        _Istream_Cstr skip( unsigned int wd ) { return (_Istream_Cstr)@{ 0p, { {0p}, wd, {.all : 0} } }; }
    436440        _Istream_Cstr & getline( _Istream_Cstr & fmt, const char delimit = '\n' ) {
    437441                fmt.delimit[0] = delimit; fmt.delimit[1] = '\0'; fmt.flags.delimit = true; fmt.flags.inex = true; return fmt; }
    438442        _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
    439443        _Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
    440         _Istream_Cstr ignore( char s[] ) { return (_Istream_Cstr)@{ s, {0p}, -1, {.flags.ignore : true} }; }
     444        _Istream_Cstr ignore( char s[] ) { return (_Istream_Cstr)@{ s, { {0p}, -1, {.flags.ignore : true} } }; }
    441445        _Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
    442446} // distribution
Note: See TracChangeset for help on using the changeset viewer.