Changeset 36ebd03 for src/libcfa


Ignore:
Timestamp:
Mar 3, 2016, 1:28:56 PM (10 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc
Children:
3627356
Parents:
9d7b3ea (diff), 4040425 (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:
src/libcfa
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/Makefile.in

    r9d7b3ea r36ebd03  
    231231          esac; \
    232232        done; \
    233         echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/libcfa/Makefile'; \
     233        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/libcfa/Makefile'; \
    234234        $(am__cd) $(top_srcdir) && \
    235           $(AUTOMAKE) --gnu src/libcfa/Makefile
     235          $(AUTOMAKE) --foreign src/libcfa/Makefile
    236236.PRECIOUS: Makefile
    237237Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

  • src/libcfa/builtins.cf

    r9d7b3ea r36ebd03  
    390390int __builtin_sprintf(char *, const char *, ...);
    391391int __builtin_sscanf(const char *, const char *, ...);
    392 int __builtin_vfprintf(struct _IO_FILE *, const char *, void **);
    393 int __builtin_vfscanf(struct _IO_FILE *, const char *, void **);
    394 int __builtin_vprintf(const char *, void **);
    395 int __builtin_vscanf(const char *, void **);
    396 int __builtin_vsnprintf(char *, unsigned long, const char *, void **);
    397 int __builtin_vsprintf(char *, const char *, void **);
    398 int __builtin_vsscanf(const char *, const char *, void **);
     392int __builtin_vfprintf(struct _IO_FILE *, const char *, __builtin_va_list);
     393int __builtin_vfscanf(struct _IO_FILE *, const char *, __builtin_va_list);
     394int __builtin_vprintf(const char *, __builtin_va_list);
     395int __builtin_vscanf(const char *, __builtin_va_list);
     396int __builtin_vsnprintf(char *, unsigned long, const char *, __builtin_va_list);
     397int __builtin_vsprintf(char *, const char *, __builtin_va_list);
     398int __builtin_vsscanf(const char *, const char *, __builtin_va_list);
    399399int __builtin_isalnum(int);
    400400int __builtin_isalpha(int);
    … …  
    534534void __builtin_unwind_init();
    535535void __builtin_update_setjmp_buf(void *, int);
    536 void __builtin_va_copy(void **, void **);
    537 void __builtin_va_end(void **);
    538 void __builtin_va_start(void **, ...);
     536void __builtin_va_copy(__builtin_va_list, __builtin_va_list);
     537void __builtin_va_end(__builtin_va_list);
     538void __builtin_va_start(__builtin_va_list, ...);
    539539int __builtin_va_arg_pack();
    540540int __builtin_va_arg_pack_len();
    … …  
    563563int __builtin___snprintf_chk(char *, unsigned long, int, unsigned long, const char *, ...);
    564564int __builtin___sprintf_chk(char *, int, unsigned long, const char *, ...);
    565 int __builtin___vsnprintf_chk(char *, unsigned long, int, unsigned long, const char *, void **);
    566 int __builtin___vsprintf_chk(char *, int, unsigned long, const char *, void **);
     565int __builtin___vsnprintf_chk(char *, unsigned long, int, unsigned long, const char *, __builtin_va_list);
     566int __builtin___vsprintf_chk(char *, int, unsigned long, const char *, __builtin_va_list);
    567567int __builtin___fprintf_chk(struct _IO_FILE *, int, const char *, ...);
    568568int __builtin___printf_chk(int, const char *, ...);
    569 int __builtin___vfprintf_chk(struct _IO_FILE *, int, const char *, void **);
    570 int __builtin___vprintf_chk(int, const char *, void **);
     569int __builtin___vfprintf_chk(struct _IO_FILE *, int, const char *, __builtin_va_list);
     570int __builtin___vprintf_chk(int, const char *, __builtin_va_list);
    571571void __cyg_profile_func_enter(void *, void *);
    572572void __cyg_profile_func_exit(void *, void *);
    … …  
    583583const char * __builtin_FUNCTION();
    584584int __builtin_LINE();
    585 typedef void ** __builtin_va_list;
    586585extern const char *__PRETTY_FUNCTION__;
    587586typedef int wchar_t;

  • src/libcfa/fstream

    r9d7b3ea r36ebd03  
    77// fstream --
    88//
    9 // Author           : Richard C. Bilson
     9// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 17 14:02:01 2016
    13 // Update Count     : 22
     12// Last Modified On : Wed Mar  2 15:08:14 2016
     13// Update Count     : 78
    1414//
    1515
    … …  
    1919#include "iostream"
    2020
    21 // implement context ostream
    22 struct ofstream;
     21enum { separateSize = 16 };
     22struct ofstream { void *file; int separate; char separator[separateSize]; };
    2323
    24 int fail( ofstream * os );
    25 int flush( ofstream * os );
    26 void open( ofstream ** os, const char * name, const char * mode );
    27 void close( ofstream * os );
    28 ofstream * write( ofstream * os, const char * data, streamsize_type size );
     24_Bool sepPrt( ofstream * );
     25void sepOn( ofstream * );
     26void sepOff( ofstream * );
     27void sepSet( ofstream *, const char * );
     28const char * sepGet( ofstream * );
     29void sepDisable( ofstream * );
     30void sepEnable( ofstream * );
     31int fail( ofstream * );
     32int flush( ofstream * );
     33void open( ofstream *, const char * name, const char * mode );
     34void close( ofstream * );
     35ofstream * write( ofstream *, const char * data, unsigned long int size );
     36int prtfmt( ofstream *, const char fmt[], ... );
    2937
    3038extern ofstream * sout, * serr;
    3139
    3240// implement context istream
    33 struct ifstream;
     41struct ifstream { void *file; };
    3442
    3543int fail( ifstream * is );
    3644int eof( ifstream * is );
    37 void open( ifstream ** is, const char * name, const char * mode );
     45void open( ifstream * is, const char * name, const char * mode );
    3846void close( ifstream * is );
    39 ifstream * get( ifstream * is, int * data );
    40 ifstream * read( ifstream * is, char * data, streamsize_type size );
     47ifstream * read( ifstream * is, char * data, unsigned long int size );
    4148ifstream * ungetc( ifstream * is, char c );
     49int scanfmt( ifstream *, const char fmt[], ... );
    4250
    4351extern ifstream *sin;
    … …  
    4957// tab-width: 4 //
    5058// End: //
     59

  • src/libcfa/fstream.c

    r9d7b3ea r36ebd03  
    77// fstream.c --
    88//
    9 // Author           : Richard C. Bilson
     9// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 17 14:03:05 2016
    13 // Update Count     : 76
     12// Last Modified On : Mon Feb 29 18:41:10 2016
     13// Update Count     : 162
    1414//
    1515
    … …  
    1717
    1818extern "C" {
    19 #include <stdio.h>
    20 #include <stdlib.h>
     19#include <stdio.h>                                                                              // vfprintf, vfscanf
     20#include <stdlib.h>                                                                             // exit
     21#include <stdarg.h>                                                                             // varargs
     22#include <string.h>                                                                             // strlen
     23#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
     24#include <complex.h>                                                                    // creal, cimag
    2125}
    22 
    23 struct ofstream {
    24         FILE *file;
    25 };
    2626
    2727#define IO_MSG "I/O error "
    2828
     29_Bool sepPrt( ofstream * os ) { return os->separate == 1; }
     30void sepOn( ofstream * os ) { if ( os->separate != 2 ) os->separate = 1; }
     31void sepOff( ofstream * os ) { if ( os->separate != 2 ) os->separate = 0; }
     32void sepSet( ofstream * os, const char * s ) {
     33        strncpy( &(os->separator[0]), s, separateSize - 1 );
     34        os->separator[separateSize - 1] = '\0';
     35} // sepSet
     36const char * sepGet( ofstream * os ) { return &(os->separator[0]); }
     37void sepDisable( ofstream *os ) { os->separate = 2; }
     38void sepEnable( ofstream *os ) { os->separate = 0; }
     39
    2940int fail( ofstream * os ) {
    30         return ferror( os->file );
     41        return ferror( (FILE *)(os->file) );
    3142} // fail
    3243
    3344int flush( ofstream * os ) {
    34         return fflush( os->file );
     45        return fflush( (FILE *)(os->file) );
    3546} // flush
    3647
    37 void open( ofstream ** os, const char * name, const char * mode ) {
    38         FILE *t = fopen( name, mode );
    39         if ( t == 0 ) {                                                                         // do not change unless successful
     48void open( ofstream * os, const char * name, const char * mode ) {
     49        FILE *file = fopen( name, mode );
     50        if ( file == 0 ) {                                                                      // do not change unless successful
    4051                perror( IO_MSG "open output" );
    4152                exit( EXIT_FAILURE );
    4253        } // if
    43         (*os)->file = t;
     54        os->file = file;
     55        sepOff( os );
     56        sepSet( os, " " );
    4457} // open
    4558
    4659void close( ofstream * os ) {
    47         if ( os->file == stdout || os->file == stderr ) return;
     60        if ( (FILE *)(os->file) == stdout || (FILE *)(os->file) == stderr ) return;
    4861
    49         if ( fclose( os->file ) == EOF ) {
     62        if ( fclose( (FILE *)(os->file) ) == EOF ) {
    5063                perror( IO_MSG "close output" );
    5164        } // if
    5265} // close
    5366
    54 ofstream * write( ofstream * os, const char * data, streamsize_type size ) {
     67ofstream * write( ofstream * os, const char * data, unsigned long int size ) {
    5568        if ( fail( os ) ) {
    5669                fprintf( stderr, "attempt write I/O on failed stream\n" );
    … …  
    5871        } // if
    5972
    60         if ( fwrite( data, 1, size, os->file ) != size ) {
     73        if ( fwrite( data, 1, size, (FILE *)(os->file) ) != size ) {
    6174                perror( IO_MSG "write" );
    6275                exit( EXIT_FAILURE );
    … …  
    6578} // write
    6679
    67 static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
     80int prtfmt( ofstream * os, const char fmt[], ... ) {
     81    va_list args;
     82
     83    va_start( args, fmt );
     84    int len = vfprintf( (FILE *)(os->file), fmt, args );
     85        if ( len == EOF ) {
     86                if ( ferror( (FILE *)(os->file) ) ) {
     87                        fprintf( stderr, "invalid write\n" );
     88                        exit( EXIT_FAILURE );
     89                } // if
     90        } // if
     91    va_end( args );
     92        return len;
     93} // prtfmt
     94
     95
     96static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 0, { ' ', '\0' } };
    6897ofstream *sout = &soutFile;
    69 static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
     98static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 0, { ' ', '\0' } };
    7099ofstream *serr = &serrFile;
     100
    71101
    72102//---------------------------------------
    73103
    74 struct ifstream {
    75         FILE *file;
    76 };
    77104
    78105int fail( ifstream * is ) {
    79         return ferror( is->file );
     106        return ferror( (FILE *)(is->file) );
    80107} // fail
    81108
    82109int eof( ifstream * is ) {
    83         return feof( is->file );
     110        return feof( (FILE *)(is->file) );
    84111} // eof
    85112
    86 ifstream * get( ifstream * is, int * data ) {
    87         if ( fscanf( is->file, "%d", data ) == EOF ) {
    88                 if ( ferror( is->file ) ) {
    89                         fprintf( stderr, "invalid int read\n" );
    90                         exit( EXIT_FAILURE );
    91                 } // if
     113void open( ifstream * is, const char * name, const char * mode ) {
     114        FILE *t = fopen( name, mode );
     115        if ( t == 0 ) {                                                                         // do not change unless successful
     116                perror( IO_MSG "open input" );
     117                exit( EXIT_FAILURE );
    92118        } // if
    93         return is;
    94 } // read
     119        is->file = t;
     120} // open
    95121
    96 ifstream * read( ifstream * is, char * data, streamsize_type size ) {
     122void close( ifstream * is ) {
     123        if ( (FILE *)(is->file) == stdin ) return;
     124
     125        if ( fclose( (FILE *)(is->file) ) == EOF ) {
     126                perror( IO_MSG "close input" );
     127        } // if
     128} // close
     129
     130ifstream * read( ifstream * is, char * data, unsigned long int size ) {
    97131        if ( fail( is ) ) {
    98132                fprintf( stderr, "attempt read I/O on failed stream\n" );
    … …  
    100134        } // if
    101135
    102         if ( fread( data, size, 1, is->file ) == 0 ) {
     136        if ( fread( data, size, 1, (FILE *)(is->file) ) == 0 ) {
    103137                perror( IO_MSG "read" );
    104138                exit( EXIT_FAILURE );
    … …  
    113147        } // if
    114148
    115         if ( ungetc( c, is->file ) == EOF ) {
     149        if ( ungetc( c, (FILE *)(is->file) ) == EOF ) {
    116150                perror( IO_MSG "ungetc" );
    117151                exit( EXIT_FAILURE );
    … …  
    120154} // ungetc
    121155
    122 void open( ifstream ** is, const char * name, const char * mode ) {
    123         FILE *t = fopen( name, mode );
    124         if ( t == 0 ) {                                                                         // do not change unless successful
    125                 perror( IO_MSG "open input" );
    126                 exit( EXIT_FAILURE );
     156int scanfmt( ifstream * is, const char fmt[], ... ) {
     157    va_list args;
     158
     159    va_start( args, fmt );
     160    int len = vfscanf( (FILE *)(is->file), fmt, args );
     161        if ( len == EOF ) {
     162                if ( ferror( (FILE *)(is->file) ) ) {
     163                        fprintf( stderr, "invalid read\n" );
     164                        exit( EXIT_FAILURE );
     165                } // if
    127166        } // if
    128         (*is)->file = t;
    129 } // open
     167    va_end( args );
     168        return len;
     169} // prtfmt
    130170
    131 void close( ifstream * is ) {
    132         if ( is->file == stdin ) return;
    133 
    134         if ( fclose( is->file ) == EOF ) {
    135                 perror( IO_MSG "close input" );
    136         } // if
    137 } // close
    138171
    139172static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) };

  • src/libcfa/iostream

    r9d7b3ea r36ebd03  
    77// iostream --
    88//
    9 // Author           : Richard C. Bilson
     9// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 17 14:04:24 2016
    13 // Update Count     : 32
     12// Last Modified On : Wed Mar  2 18:05:27 2016
     13// Update Count     : 85
    1414//
    1515
    16 #ifndef IOSTREAM_H
    17 #define IOSTREAM_H
     16#ifndef __IOSTREAM_H__
     17#define __IOSTREAM_H__
    1818
    1919#include "iterator"
    2020
    21 typedef unsigned long streamsize_type;
    22 
    23 context ostream( dtype ostype ) {
     21trait ostream( dtype ostype ) {
     22        _Bool sepPrt( ostype * );
     23        void sepOn( ostype * );
     24        void sepOff( ostype * );
     25        void sepSet( ostype *, const char * );
     26        const char * sepGet( ostype * );
     27        void sepDisable( ostype * );
     28        void sepEnable( ostype * );
    2429        int fail( ostype * );
    2530        int flush( ostype * );
    26         ostype * write( ostype *, const char *, streamsize_type );
     31        void open( ostype * os, const char * name, const char * mode );
     32        void close( ostype * os );
     33        ostype * write( ostype *, const char *, unsigned long int );
     34        int prtfmt( ostype *, const char fmt[], ... );
    2735};
    28 context writeable( type T ) {
     36
     37trait writeable( otype T ) {
    2938        forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
    3039};
    … …  
    3342
    3443forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, char );
     44
     45forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, short int );
     46forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned short int );
    3547forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, int );
    3648forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned int );
    … …  
    3951forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned long int );
    4052forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned long long int );
     53
    4154forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, float ); // FIX ME: should not be required
    4255forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double );
    4356forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, long double );
     57
    4458forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, float _Complex );
    4559forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double _Complex );
    4660forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, long double _Complex );
     61
    4762forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
    4863forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
    4964
    50 forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) retostype * ?|?( ostype *os, retostype * (* manip)(ostype*) );
     65forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, ostype * (*)( ostype * ) );
    5166forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * );
     67forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * );
     68forall( dtype ostype | ostream( ostype ) ) ostype * sepOff( ostype * );
    5269
    5370// writes the range [begin, end) to the given stream
    54 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
     71forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
    5572void write( iterator_type begin, iterator_type end, os_type *os );
    5673
    57 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
     74forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
    5875void write_reverse( iterator_type begin, iterator_type end, os_type *os );
    5976
    6077//---------------------------------------
    6178
    62 context istream( dtype istype ) {
     79trait istream( dtype istype ) {
    6380        int fail( istype * );
    6481        int eof( istype * );
    65         istype * get( istype *, int * );
    66         istype * read( istype *, char *, streamsize_type );
     82        void open( istype * is, const char * name, const char * mode );
     83        void close( istype * is );
     84        istype * read( istype *, char *, unsigned long int );
    6785        istype * ungetc( istype *, char );
     86        int scanfmt( istype *, const char fmt[], ... );
    6887};
    6988
    70 context readable( type T ) {
     89trait readable( otype T ) {
    7190        forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T );
    7291};
    7392
    74 forall( dtype istype | istream( istype ) )
    75 istype * ?|?( istype *, char * );
     93forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char * );
    7694
    77 forall( dtype istype | istream( istype ) )
    78 istype * ?|?( istype *, int * );
     95forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int * );
     96forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned short int * );
     97forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, int * );
     98forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned int * );
     99forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long int * );
     100forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long long int * );
     101forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long int * );
     102forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long long int * );
    79103
    80 #endif // IOSTREAM_H
     104forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float * );
     105forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double * );
     106forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double * );
     107
     108forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float _Complex * );
     109forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double _Complex * );
     110forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
     111
     112struct _Istream_str1 { char * s; };
     113_Istream_str1 str( char * );
     114forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str1 );
     115
     116struct _Istream_str2 { char * s; int size; };
     117_Istream_str2 str( char *, int size );
     118forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str2 );
     119
     120#endif // __IOSTREAM_H__
    81121
    82122// Local Variables: //

  • src/libcfa/iostream.c

    r9d7b3ea r36ebd03  
    77// iostream.c --
    88//
    9 // Author           : Richard C. Bilson
     9// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 17 14:19:56 2016
    13 // Update Count     : 76
     12// Last Modified On : Wed Mar  2 18:06:35 2016
     13// Update Count     : 208
    1414//
    1515
    … …  
    2121#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
    2222#include <complex.h>                                                                    // creal, cimag
     23#include <ctype.h>                                                                              // isspace, ispunct
    2324}
    2425
    2526forall( dtype ostype | ostream( ostype ) )
    2627ostype * ?|?( ostype *os, char c ) {
    27         return write( os, &c, 1 );
     28        prtfmt( os, "%c", c );
     29        return os;
     30} // ?|?
     31
     32forall( dtype ostype | ostream( ostype ) )
     33ostype * ?|?( ostype *os, short int si ) {
     34        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     35        prtfmt( os, "%hd", si );
     36        return os;
     37} // ?|?
     38
     39forall( dtype ostype | ostream( ostype ) )
     40ostype * ?|?( ostype *os, unsigned short int usi ) {
     41        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     42        prtfmt( os, "%hu", usi );
     43        return os;
    2844} // ?|?
    2945
    3046forall( dtype ostype | ostream( ostype ) )
    3147ostype * ?|?( ostype *os, int i ) {
    32         char buffer[32];
    33         return write( os, buffer, sprintf( buffer, "%d", i ) );
    34 } // ?|?
    35 
    36 forall( dtype ostype | ostream( ostype ) )
    37 ostype * ?|?( ostype *os, unsigned int i ) {
    38         char buffer[32];
    39         return write( os, buffer, sprintf( buffer, "%u", i ) );
    40 } // ?|?
    41 
    42 forall( dtype ostype | ostream( ostype ) )
    43 ostype * ?|?( ostype *os, long int i ) {
    44         char buffer[32];
    45         return write( os, buffer, sprintf( buffer, "%ld", i ) );
    46 } // ?|?
    47 
    48 forall( dtype ostype | ostream( ostype ) )
    49 ostype * ?|?( ostype *os, long long int i ) {
    50         char buffer[32];
    51         return write( os, buffer, sprintf( buffer, "%lld", i ) );
    52 } // ?|?
    53 
    54 forall( dtype ostype | ostream( ostype ) )
    55 ostype * ?|?( ostype *os, unsigned long int i ) {
    56         char buffer[32];
    57         return write( os, buffer, sprintf( buffer, "%lu", i ) );
    58 } // ?|?
    59 
    60 forall( dtype ostype | ostream( ostype ) )
    61 ostype * ?|?( ostype *os, unsigned long long int i ) {
    62         char buffer[32];
    63         return write( os, buffer, sprintf( buffer, "%llu", i ) );
     48        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     49        prtfmt( os, "%d", i );
     50        return os;
     51} // ?|?
     52
     53forall( dtype ostype | ostream( ostype ) )
     54ostype * ?|?( ostype *os, unsigned int ui ) {
     55        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     56        prtfmt( os, "%u", ui );
     57        return os;
     58} // ?|?
     59
     60forall( dtype ostype | ostream( ostype ) )
     61ostype * ?|?( ostype *os, long int li ) {
     62        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     63        prtfmt( os, "%ld", li );
     64        return os;
     65} // ?|?
     66
     67forall( dtype ostype | ostream( ostype ) )
     68ostype * ?|?( ostype *os, unsigned long int uli ) {
     69        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     70        prtfmt( os, "%lu", uli );
     71        return os;
     72} // ?|?
     73
     74forall( dtype ostype | ostream( ostype ) )
     75ostype * ?|?( ostype *os, long long int lli ) {
     76        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     77        prtfmt( os, "%lld", lli );
     78        return os;
     79} // ?|?
     80
     81forall( dtype ostype | ostream( ostype ) )
     82ostype * ?|?( ostype *os, unsigned long long int ulli ) {
     83        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     84        prtfmt( os, "%llu", ulli );
     85        return os;
    6486} // ?|?
    6587
    6688forall( dtype ostype | ostream( ostype ) )
    6789ostype * ?|?( ostype *os, float f ) {
    68         char buffer[32];
    69         return write( os, buffer, sprintf( buffer, "%g", f ) );
     90        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     91        prtfmt( os, "%g", f );
     92        return os;
    7093} // ?|?
    7194
    7295forall( dtype ostype | ostream( ostype ) )
    7396ostype * ?|?( ostype *os, double d ) {
    74         char buffer[32];
    75         return write( os, buffer, sprintf( buffer, "%.*lg", DBL_DIG, d ) );
    76 } // ?|?
    77 
    78 forall( dtype ostype | ostream( ostype ) )
    79 ostype * ?|?( ostype *os, long double d ) {
    80         char buffer[32];
    81         return write( os, buffer, sprintf( buffer, "%.*Lg", LDBL_DIG, d ) );
    82 } // ?|?
    83 
    84 forall( dtype ostype | ostream( ostype ) )
    85 ostype * ?|?( ostype *os, float _Complex c ) {
    86         return os | crealf( c ) | (cimagf( c ) < 0 ? "" : "+") | cimagf( c ) | 'i';
    87 } // ?|?
    88 
    89 forall( dtype ostype | ostream( ostype ) )
    90 ostype * ?|?( ostype *os, double _Complex c ) {
    91         return os | creal( c ) | (cimag( c ) < 0 ? "" : "+") | cimag( c ) | 'i';
    92 } // ?|?
    93 
    94 forall( dtype ostype | ostream( ostype ) )
    95 ostype * ?|?( ostype *os, long double _Complex c ) {
    96         return os | creall( c ) | (cimagl( c ) < 0 ? "" : "+") | cimagl( c ) | 'i';
     97        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     98        prtfmt( os, "%.*lg", DBL_DIG, d );
     99        return os;
     100} // ?|?
     101
     102forall( dtype ostype | ostream( ostype ) )
     103ostype * ?|?( ostype *os, long double ld ) {
     104        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     105        prtfmt( os, "%.*Lg", LDBL_DIG, ld );
     106        return os;
     107} // ?|?
     108
     109forall( dtype ostype | ostream( ostype ) )
     110ostype * ?|?( ostype *os, float _Complex fc ) {
     111        os | crealf( fc );
     112        if ( cimagf( fc ) >= 0 ) os | '+';
     113        os | "" | cimagf( fc ) | 'i';
     114        return os;
     115} // ?|?
     116
     117forall( dtype ostype | ostream( ostype ) )
     118ostype * ?|?( ostype *os, double _Complex dc ) {
     119        os | creal( dc );
     120        if ( cimag( dc ) >= 0 ) os | '+';
     121        os | "" | cimag( dc ) | 'i';
     122        return os;
     123} // ?|?
     124
     125forall( dtype ostype | ostream( ostype ) )
     126ostype * ?|?( ostype *os, long double _Complex ldc ) {
     127        os | creall( ldc );
     128        if ( cimagl( ldc ) >= 0 ) os | '+';
     129        os | "" | cimagl( ldc ) | 'i';
     130        return os;
     131} // ?|?
     132
     133forall( dtype ostype | ostream( ostype ) )
     134ostype * ?|?( ostype *os, const char *cp ) {
     135        int len = strlen( cp );
     136        // null string => no separator
     137  if ( len == 0 ) { sepOff( os ); return os; }
     138        // first character NOT spacing or special punctuation => add left separator
     139        if ( sepPrt( os ) && isspace( cp[0] ) == 0 && cp[0] != '.' && cp[0] != ',' ) {
     140                prtfmt( os, "%s", sepGet( os ) );
     141        } // if
     142        // last character is spacing or special punctuation => turn off separator for next item
     143        unsigned int posn = len - 1;
     144        if ( isspace( cp[posn] ) || cp[posn] == ':' || cp[posn] == '$' ) {
     145                sepOff( os );
     146        } else {
     147                sepOn( os );
     148        } // if
     149        return write( os, cp, len );
    97150} // ?|?
    98151
    99152forall( dtype ostype | ostream( ostype ) )
    100153ostype * ?|?( ostype *os, const void *p ) {
    101         char buffer[32];
    102         return write( os, buffer, sprintf( buffer, "%p", p ) );
    103 } // ?|?
    104 
    105 forall( dtype ostype | ostream( ostype ) )
    106 ostype * ?|?( ostype *os, const char *cp ) {
    107         return write( os, cp, strlen( cp ) );
    108 } // ?|?
    109 
    110 
    111 forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) )
    112 retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) {
    113   return manip( os );
    114 }
     154        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
     155        prtfmt( os, "%p", p );
     156        return os;
     157} // ?|?
     158
     159
     160forall( dtype ostype | ostream( ostype ) )
     161ostype * ?|?( ostype *os, ostype * (* manip)( ostype * ) ) {
     162        return manip( os );
     163} // ?|?
    115164
    116165forall( dtype ostype | ostream( ostype ) )
    117166ostype * endl( ostype * os ) {
    118         os | "\n";
     167        os | '\n';
    119168        flush( os );
     169        sepOff( os );
    120170        return os;
    121171} // endl
    122172
     173forall( dtype ostype | ostream( ostype ) )
     174ostype * sepOn( ostype * os ) {
     175        sepOn( os );
     176        return os;
     177} // sepOn
     178
     179forall( dtype ostype | ostream( ostype ) )
     180ostype * sepOff( ostype * os ) {
     181        sepOff( os );
     182        return os;
     183} // sepOff
     184
    123185//---------------------------------------
    124186
    125 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
    126                 dtype os_type | ostream( os_type ) )
    127 void write( iterator_type begin, iterator_type end, os_type *os ) {
    128         void print( elt_type i ) { os | i | ' '; }
     187forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
     188void write( iteratortype begin, iteratortype end, ostype *os ) {
     189        void print( elttype i ) { os | i; }
    129190        for_each( begin, end, print );
    130191} // ?|?
    131192
    132 forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
    133                 dtype os_type | ostream( os_type ) )
    134 void write_reverse( iterator_type begin, iterator_type end, os_type *os ) {
    135         void print( elt_type i ) { os | i | ' '; }
     193forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
     194void write_reverse( iteratortype begin, iteratortype end, ostype *os ) {
     195        void print( elttype i ) { os | i; }
    136196        for_each_reverse( begin, end, print );
    137197} // ?|?
    … …  
    140200
    141201forall( dtype istype | istream( istype ) )
    142 istype * ?|?( istype *is, char *cp ) {
    143         return read( is, cp, 1 );
    144 } // ?|?
    145 
    146 forall( dtype istype | istream( istype ) )
    147 istype * ?|?( istype *is, int *ip ) {
    148         return get( is, ip );
    149 } // ?|?
     202istype * ?|?( istype * is, char * c ) {
     203        scanfmt( is, "%c", c );
     204        return is;
     205} // ?|?
     206
     207forall( dtype istype | istream( istype ) )
     208istype * ?|?( istype * is, short int * si ) {
     209        scanfmt( is, "%hd", si );
     210        return is;
     211} // ?|?
     212
     213forall( dtype istype | istream( istype ) )
     214istype * ?|?( istype * is, unsigned short int * usi ) {
     215        scanfmt( is, "%hu", usi );
     216        return is;
     217} // ?|?
     218
     219forall( dtype istype | istream( istype ) )
     220istype * ?|?( istype * is, int * i ) {
     221        scanfmt( is, "%d", i );
     222        return is;
     223} // ?|?
     224
     225forall( dtype istype | istream( istype ) )
     226istype * ?|?( istype * is, unsigned int * ui ) {
     227        scanfmt( is, "%u", ui );
     228        return is;
     229} // ?|?
     230
     231forall( dtype istype | istream( istype ) )
     232istype * ?|?( istype * is, long int * li ) {
     233        scanfmt( is, "%ld", li );
     234        return is;
     235} // ?|?
     236
     237forall( dtype istype | istream( istype ) )
     238istype * ?|?( istype * is, unsigned long int * ulli ) {
     239        scanfmt( is, "%lu", ulli );
     240        return is;
     241} // ?|?
     242
     243forall( dtype istype | istream( istype ) )
     244istype * ?|?( istype * is, long long int * lli ) {
     245        scanfmt( is, "%lld", lli );
     246        return is;
     247} // ?|?
     248
     249forall( dtype istype | istream( istype ) )
     250istype * ?|?( istype * is, unsigned long long int * ulli ) {
     251        scanfmt( is, "%llu", ulli );
     252        return is;
     253} // ?|?
     254
     255
     256forall( dtype istype | istream( istype ) )
     257istype * ?|?( istype * is, float * f ) {
     258        scanfmt( is, "%f", f );
     259        return is;
     260} // ?|?
     261
     262forall( dtype istype | istream( istype ) )
     263istype * ?|?( istype * is, double * d ) {
     264        scanfmt( is, "%lf", d );
     265        return is;
     266} // ?|?
     267
     268forall( dtype istype | istream( istype ) )
     269istype * ?|?( istype * is, long double * ld ) {
     270        scanfmt( is, "%Lf", ld );
     271        return is;
     272} // ?|?
     273
     274
     275forall( dtype istype | istream( istype ) )
     276istype * ?|?( istype * is, float _Complex * fc ) {
     277        float re, im;
     278        scanfmt( is, "%g%gi", &re, &im );
     279        *fc = re + im * _Complex_I;
     280        return is;
     281} // ?|?
     282
     283forall( dtype istype | istream( istype ) )
     284istype * ?|?( istype * is, double _Complex * dc ) {
     285        double re, im;
     286        scanfmt( is, "%lf%lfi", &re, &im );
     287        *dc = re + im * _Complex_I;
     288        return is;
     289} // ?|?
     290
     291forall( dtype istype | istream( istype ) )
     292istype * ?|?( istype * is, long double _Complex * ldc ) {
     293        long double re, im;
     294        scanfmt( is, "%Lf%Lfi", &re, &im );
     295        *ldc = re + im * _Complex_I;
     296        return is;
     297} // ?|?
     298
     299_Istream_str1 str( char * s ) { _Istream_str1 s = { s }; return s; }
     300forall( dtype istype | istream( istype ) )
     301istype * ?|?( istype * is, _Istream_str1 str ) {
     302        scanfmt( is, "%s", str.s );
     303        return is;
     304} // str
     305
     306_Istream_str2 str( char * s, int size ) { _Istream_str2 s = { s, size }; return s; }
     307forall( dtype istype | istream( istype ) )
     308istype * ?|?( istype * is, _Istream_str2 str ) {
     309        char buf[16];
     310        sprintf( buf, "%%%ds", str.size );
     311        scanfmt( is, buf, str.s );
     312        return is;
     313} // str
    150314
    151315// Local Variables: //

  • src/libcfa/iterator

    r9d7b3ea r36ebd03  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jan 27 23:49:13 2016
    13 // Update Count     : 7
     12// Last Modified On : Wed Mar  2 18:06:05 2016
     13// Update Count     : 9
    1414//
    1515
    … …  
    1818
    1919// An iterator can be used to traverse a data structure.
    20 context iterator( type iterator_type, type elt_type ) {
     20trait iterator( otype iterator_type, otype elt_type ) {
    2121        // point to the next element
    2222//      iterator_type ?++( iterator_type * );
    … …  
    3232};
    3333
    34 context iterator_for( type iterator_type, type collection_type, type elt_type | iterator( iterator_type, elt_type ) ) {
     34trait iterator_for( otype iterator_type, otype collection_type, otype elt_type | iterator( iterator_type, elt_type ) ) {
    3535//      [ iterator_type begin, iterator_type end ] get_iterators( collection_type );
    3636        iterator_type begin( collection_type );
    … …  
    3838};
    3939
    40 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
     40forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
    4141void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
    4242
    43 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
     43forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
    4444void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
    4545

  • src/libcfa/iterator.c

    r9d7b3ea r36ebd03  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jan 26 17:16:07 2016
    13 // Update Count     : 26
     12// Last Modified On : Wed Mar  2 18:08:11 2016
     13// Update Count     : 27
    1414//
    1515
    1616#include "iterator"
    1717
    18 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
     18forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
    1919void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
    2020        for ( iterator_type i = begin; i != end; ++i ) {
    … …  
    2323}
    2424
    25 forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
     25forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
    2626void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
    2727        for ( iterator_type i = end; i != begin; ) {

  • src/libcfa/prelude.cf

    r9d7b3ea r36ebd03  
     1# 2 "prelude.cf"  // needed for error messages from this file
    12//                               -*- Mode: C -*-
    23//
    … …  
    89// Created On       : Sat Nov 29 07:23:41 2014
    910// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Mon Jan  4 11:13:26 2016
    11 // Update Count     : 81
     11// Last Modified On : Wed Mar  2 18:03:41 2016
     12// Update Count     : 89
    1213//
    1314
    … …  
    6364long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
    6465
    65 forall( type T ) T *                     ?++(                T ** );
    66 forall( type T ) const T *               ?++( const          T ** );
    67 forall( type T ) volatile T *            ?++(       volatile T ** );
    68 forall( type T ) const volatile T *      ?++( const volatile T ** );
    69 forall( type T ) T *                     ?--(                T ** );
    70 forall( type T ) const T *               ?--( const          T ** );
    71 forall( type T ) volatile T *            ?--(       volatile T ** );
    72 forall( type T ) const volatile T *      ?--( const volatile T ** );
    73 
    74 forall( type T ) lvalue T                ?[?](                T *,          ptrdiff_t );
    75 forall( type T ) const lvalue T          ?[?]( const          T *,          ptrdiff_t );
    76 forall( type T ) volatile lvalue T       ?[?](       volatile T *,          ptrdiff_t );
    77 forall( type T ) const volatile lvalue T ?[?]( const volatile T *,          ptrdiff_t );
    78 forall( type T ) lvalue T                ?[?](          ptrdiff_t,                T * );
    79 forall( type T ) const lvalue T          ?[?](          ptrdiff_t, const          T * );
    80 forall( type T ) volatile lvalue T       ?[?](          ptrdiff_t,       volatile T * );
    81 forall( type T ) const volatile lvalue T ?[?](          ptrdiff_t, const volatile T * );
     66forall( otype T ) T *                    ?++(                T ** );
     67forall( otype T ) const T *              ?++( const          T ** );
     68forall( otype T ) volatile T *           ?++(       volatile T ** );
     69forall( otype T ) const volatile T *     ?++( const volatile T ** );
     70forall( otype T ) T *                    ?--(                T ** );
     71forall( otype T ) const T *              ?--( const          T ** );
     72forall( otype T ) volatile T *           ?--(       volatile T ** );
     73forall( otype T ) const volatile T *     ?--( const volatile T ** );
     74
     75forall( otype T ) lvalue T               ?[?](                T *,          ptrdiff_t );
     76forall( otype T ) const lvalue T         ?[?]( const          T *,          ptrdiff_t );
     77forall( otype T ) volatile lvalue T      ?[?](       volatile T *,          ptrdiff_t );
     78forall( otype T ) const volatile lvalue T ?[?]( const volatile T *,         ptrdiff_t );
     79forall( otype T ) lvalue T               ?[?](          ptrdiff_t,                T * );
     80forall( otype T ) const lvalue T         ?[?](          ptrdiff_t, const          T * );
     81forall( otype T ) volatile lvalue T      ?[?](          ptrdiff_t,       volatile T * );
     82forall( otype T ) const volatile lvalue T ?[?](         ptrdiff_t, const volatile T * );
    8283
    8384// ------------------------------------------------------------
    … …  
    101102long double _Complex    ++?( long double _Complex * ),          --?( long double _Complex * );
    102103
    103 forall( type T ) T *                     ++?(                T ** );
    104 forall( type T ) const T *               ++?( const          T ** );
    105 forall( type T ) volatile T *            ++?(       volatile T ** );
    106 forall( type T ) const volatile T *      ++?( const volatile T ** );
    107 forall( type T ) T *                     --?(                T ** );
    108 forall( type T ) const T *               --?( const          T ** );
    109 forall( type T ) volatile T *            --?(       volatile T ** );
    110 forall( type T ) const volatile T *      --?( const volatile T ** );
    111 
    112 forall( type T ) lvalue T                *?(                 T * );
    113 forall( type T ) const lvalue T          *?( const           T * );
    114 forall( type T ) volatile lvalue T       *?(       volatile  T * );
    115 forall( type T ) const volatile lvalue T *?( const volatile  T * );
     104forall( otype T ) T *                    ++?(                T ** );
     105forall( otype T ) const T *              ++?( const          T ** );
     106forall( otype T ) volatile T *           ++?(       volatile T ** );
     107forall( otype T ) const volatile T *     ++?( const volatile T ** );
     108forall( otype T ) T *                    --?(                T ** );
     109forall( otype T ) const T *              --?( const          T ** );
     110forall( otype T ) volatile T *           --?(       volatile T ** );
     111forall( otype T ) const volatile T *     --?( const volatile T ** );
     112
     113forall( otype T ) lvalue T               *?(                 T * );
     114forall( otype T ) const lvalue T                 *?( const           T * );
     115forall( otype T ) volatile lvalue T      *?(       volatile  T * );
     116forall( otype T ) const volatile lvalue T *?( const volatile  T * );
    116117forall( ftype FT ) lvalue FT             *?( FT * );
    117118
    … …  
    183184long double _Complex    ?+?( long double _Complex, long double _Complex ),      ?-?( long double _Complex, long double _Complex );
    184185
    185 forall( type T ) T *                    ?+?(                T *,          ptrdiff_t );
    186 forall( type T ) T *                    ?+?(          ptrdiff_t,                T * );
    187 forall( type T ) const T *              ?+?( const          T *,          ptrdiff_t );
    188 forall( type T ) const T *              ?+?(          ptrdiff_t, const          T * );
    189 forall( type T ) volatile T *           ?+?(       volatile T *,          ptrdiff_t );
    190 forall( type T ) volatile T *           ?+?(          ptrdiff_t,       volatile T * );
    191 forall( type T ) const volatile T *     ?+?( const volatile T *,          ptrdiff_t );
    192 forall( type T ) const volatile T *     ?+?(          ptrdiff_t, const volatile T * );
    193 forall( type T ) T *                    ?-?(                T *,          ptrdiff_t );
    194 forall( type T ) const T *              ?-?( const          T *,          ptrdiff_t );
    195 forall( type T ) volatile T *           ?-?(       volatile T *,          ptrdiff_t );
    196 forall( type T ) const volatile T *     ?-?( const volatile T *,          ptrdiff_t );
    197 forall( type T ) ptrdiff_t              ?-?( const volatile T *, const volatile T * );
     186forall( otype T ) T *                   ?+?(                T *,          ptrdiff_t );
     187forall( otype T ) T *                   ?+?(          ptrdiff_t,                T * );
     188forall( otype T ) const T *             ?+?( const          T *,          ptrdiff_t );
     189forall( otype T ) const T *             ?+?(          ptrdiff_t, const          T * );
     190forall( otype T ) volatile T *          ?+?(       volatile T *,          ptrdiff_t );
     191forall( otype T ) volatile T *          ?+?(          ptrdiff_t,       volatile T * );
     192forall( otype T ) const volatile T *    ?+?( const volatile T *,          ptrdiff_t );
     193forall( otype T ) const volatile T *    ?+?(          ptrdiff_t, const volatile T * );
     194forall( otype T ) T *                   ?-?(                T *,          ptrdiff_t );
     195forall( otype T ) const T *             ?-?( const          T *,          ptrdiff_t );
     196forall( otype T ) volatile T *          ?-?(       volatile T *,          ptrdiff_t );
     197forall( otype T ) const volatile T *    ?-?( const volatile T *,          ptrdiff_t );
     198forall( otype T ) ptrdiff_t             ?-?( const volatile T *, const volatile T * );
    198199
    199200// ------------------------------------------------------------
    … …  
    431432forall( ftype FT ) FT *                 ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
    432433
    433 forall( type T ) T *                    ?+=?(                T *          *, ptrdiff_t );
    434 forall( type T ) T *                    ?+=?(                T * volatile *, ptrdiff_t );
    435 forall( type T ) const T *              ?+=?( const          T *          *, ptrdiff_t );
    436 forall( type T ) const T *              ?+=?( const          T * volatile *, ptrdiff_t );
    437 forall( type T ) volatile T *           ?+=?(       volatile T *          *, ptrdiff_t );
    438 forall( type T ) volatile T *           ?+=?(       volatile T * volatile *, ptrdiff_t );
    439 forall( type T ) const volatile T *     ?+=?( const volatile T *          *, ptrdiff_t );
    440 forall( type T ) const volatile T *     ?+=?( const volatile T * volatile *, ptrdiff_t );
    441 forall( type T ) T *                    ?-=?(                T *          *, ptrdiff_t );
    442 forall( type T ) T *                    ?-=?(                T * volatile *, ptrdiff_t );
    443 forall( type T ) const T *              ?-=?( const          T *          *, ptrdiff_t );
    444 forall( type T ) const T *              ?-=?( const          T * volatile *, ptrdiff_t );
    445 forall( type T ) volatile T *           ?-=?(       volatile T *          *, ptrdiff_t );
    446 forall( type T ) volatile T *           ?-=?(       volatile T * volatile *, ptrdiff_t );
    447 forall( type T ) const volatile T *     ?-=?( const volatile T *          *, ptrdiff_t );
    448 forall( type T ) const volatile T *     ?-=?( const volatile T * volatile *, ptrdiff_t );
     434forall( otype T ) T *                   ?+=?(                T *          *, ptrdiff_t );
     435forall( otype T ) T *                   ?+=?(                T * volatile *, ptrdiff_t );
     436forall( otype T ) const T *             ?+=?( const          T *          *, ptrdiff_t );
     437forall( otype T ) const T *             ?+=?( const          T * volatile *, ptrdiff_t );
     438forall( otype T ) volatile T *          ?+=?(       volatile T *          *, ptrdiff_t );
     439forall( otype T ) volatile T *          ?+=?(       volatile T * volatile *, ptrdiff_t );
     440forall( otype T ) const volatile T *    ?+=?( const volatile T *          *, ptrdiff_t );
     441forall( otype T ) const volatile T *    ?+=?( const volatile T * volatile *, ptrdiff_t );
     442forall( otype T ) T *                   ?-=?(                T *          *, ptrdiff_t );
     443forall( otype T ) T *                   ?-=?(                T * volatile *, ptrdiff_t );
     444forall( otype T ) const T *             ?-=?( const          T *          *, ptrdiff_t );
     445forall( otype T ) const T *             ?-=?( const          T * volatile *, ptrdiff_t );
     446forall( otype T ) volatile T *          ?-=?(       volatile T *          *, ptrdiff_t );
     447forall( otype T ) volatile T *          ?-=?(       volatile T * volatile *, ptrdiff_t );
     448forall( otype T ) const volatile T *    ?-=?( const volatile T *          *, ptrdiff_t );
     449forall( otype T ) const volatile T *    ?-=?( const volatile T * volatile *, ptrdiff_t );
    449450
    450451_Bool                   ?=?( _Bool *, _Bool ),                                  ?=?( volatile _Bool *, _Bool );

  • src/libcfa/stdlib

    r9d7b3ea r36ebd03  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  5 15:21:18 2016
    13 // Update Count     : 61
     12// Last Modified On : Wed Mar  2 17:38:21 2016
     13// Update Count     : 64
    1414//
    1515
    … …  
    2020} // extern "C"
    2121
    22 forall( type T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
    23 forall( type T ) T * memset( T * ptr );                                 // remove when default value available
     22forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
     23forall( otype T ) T * memset( T * ptr );                                        // remove when default value available
    2424
    25 forall( type T ) T * malloc( void );
    26 forall( type T ) T * malloc( char fill );
    27 forall( type T ) T * malloc( size_t size );
    28 forall( type T ) T * malloc( T * ptr, size_t size );
    29 forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill );
    30 forall( type T ) T * calloc( size_t size );
    31 forall( type T ) T * realloc( T * ptr, size_t size );
    32 forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill );
     25forall( otype T ) T * malloc( void );
     26forall( otype T ) T * malloc( char fill );
     27forall( otype T ) T * malloc( T * ptr, size_t size );
     28forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
     29forall( otype T ) T * calloc( size_t size );
     30forall( otype T ) T * realloc( T * ptr, size_t size );
     31forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
    3332
    34 forall( type T ) T * aligned_alloc( size_t alignment );
    35 forall( type T ) T * memalign( size_t alignment );              // deprecated
    36 forall( type T ) int posix_memalign( T ** ptr, size_t alignment );
     33forall( otype T ) T * aligned_alloc( size_t alignment );
     34forall( otype T ) T * memalign( size_t alignment );             // deprecated
     35forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
    3736
    3837//---------------------------------------
    … …  
    6665//---------------------------------------
    6766
    68 forall( type T | { int ?<?( T, T ); } )
     67forall( otype T | { int ?<?( T, T ); } )
    6968T * bsearch( const T key, const T * arr, size_t dimension );
    7069
    71 forall( type T | { int ?<?( T, T ); } )
     70forall( otype T | { int ?<?( T, T ); } )
    7271void qsort( const T * arr, size_t dimension );
    7372
    7473//---------------------------------------
    7574
    76 forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
     75forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
    7776[ T, T ] div( T t1, T t2 );
    7877
    … …  
    108107//---------------------------------------
    109108
    110 forall( type T | { int ?<?( T, T ); } )
     109forall( otype T | { int ?<?( T, T ); } )
    111110T min( const T t1, const T t2 );
    112111
    113 forall( type T | { int ?>?( T, T ); } )
     112forall( otype T | { int ?>?( T, T ); } )
    114113T max( const T t1, const T t2 );
    115114
    116 forall( type T )
     115forall( otype T )
    117116void swap( T * t1, T * t2 );
    118117

  • src/libcfa/stdlib.c

    r9d7b3ea r36ebd03  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 10 15:45:56 2016
    13 // Update Count     : 140
     12// Last Modified On : Wed Mar  2 17:38:47 2016
     13// Update Count     : 143
    1414//
    1515
    … …  
    2727} // extern "C"
    2828
    29 forall( type T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
     29forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
    3030        printf( "memset1\n" );
    3131    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
    3232} // memset
    33 forall( type T ) T * memset( T * ptr ) {                                // remove when default value available
     33forall( otype T ) T * memset( T * ptr ) {                               // remove when default value available
    3434        printf( "memset2\n" );
    3535    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
    3636} // memset
    3737
    38 forall( type T ) T * malloc( void ) {
     38forall( otype T ) T * malloc( void ) {
    3939        printf( "malloc1\n" );
    4040    return (T *)malloc( sizeof(T) );
    4141} // malloc
    42 forall( type T ) T * malloc( size_t size ) {
     42forall( otype T ) T * malloc( size_t size ) {
    4343        printf( "malloc2\n" );
    4444    return (T *)(void *)malloc( size );
    4545} // malloc
    46 forall( type T ) T * malloc( char fill ) {
     46forall( otype T ) T * malloc( char fill ) {
    4747        printf( "malloc3\n" );
    4848        T * ptr = (T *)malloc( sizeof(T) );
    … …  
    5050} // malloc
    5151
    52 forall( type T ) T * calloc( size_t size ) {
     52forall( otype T ) T * calloc( size_t size ) {
    5353        printf( "calloc\n" );
    5454    return (T *)calloc( size, sizeof(T) );
    5555} // calloc
    5656
    57 forall( type T ) T * realloc( T * ptr, size_t size ) {
     57forall( otype T ) T * realloc( T * ptr, size_t size ) {
    5858        printf( "realloc1\n" );
    5959    return (T *)(void *)realloc( (void *)ptr, size );
    6060} // realloc
    61 forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
     61forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
    6262        printf( "realloc2\n" );
    6363    char * nptr = (T *)(void *)realloc( (void *)ptr, size );
    … …  
    6767} // realloc
    6868
    69 forall( type T ) T * malloc( T * ptr, size_t size ) {
     69forall( otype T ) T * malloc( T * ptr, size_t size ) {
    7070        printf( "malloc4\n" );
    7171    return (T *)realloc( ptr, size );
    7272} // malloc
    73 forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
     73forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
    7474        printf( "malloc5\n" );
    7575    return (T *)realloc( ptr, size, fill );
    7676} // malloc
    7777
    78 forall( type T ) T * aligned_alloc( size_t alignment ) {
     78forall( otype T ) T * aligned_alloc( size_t alignment ) {
    7979        printf( "aligned_alloc\n" );
    8080    return (T *)memalign( alignment, sizeof(T) );
    8181} // aligned_alloc
    8282
    83 forall( type T ) T * memalign( size_t alignment ) {
     83forall( otype T ) T * memalign( size_t alignment ) {
    8484        printf( "memalign\n" );
    8585    return (T *)memalign( alignment, sizeof(T) );
    8686} // memalign
    8787
    88 forall( type T ) int posix_memalign( T ** ptr, size_t alignment ) {
     88forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
    8989        printf( "posix_memalign\n" );
    9090    return posix_memalign( (void **)ptr, alignment, sizeof(T) );
    … …  
    123123        return ulli;
    124124}
     125
    125126float ato( const char * ptr ) {
    126127        float f;
    … …  
    138139        return ld;
    139140}
     141
    140142float _Complex ato( const char * ptr ) {
    141143        float re, im;
    … …  
    172174        return strtoull( sptr, eptr, base );
    173175}
     176
    174177float strto( const char * sptr, char ** eptr ) {
    175178        return strtof( sptr, eptr );
    … …  
    181184        return strtold( sptr, eptr );
    182185}
     186
    183187float _Complex strto( const char * sptr, char ** eptr ) {
    184188        float re, im;
    … …  
    208212//---------------------------------------
    209213
    210 forall( type T | { int ?<?( T, T ); } )
     214forall( otype T | { int ?<?( T, T ); } )
    211215T * bsearch( const T key, const T * arr, size_t dimension ) {
    212216        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    … …  
    214218} // bsearch
    215219
    216 forall( type T | { int ?<?( T, T ); } )
     220forall( otype T | { int ?<?( T, T ); } )
    217221void qsort( const T * arr, size_t dimension ) {
    218222        int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    … …  
    222226//---------------------------------------
    223227
    224 forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
     228forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
    225229[ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
    226230
    … …  
    253257//---------------------------------------
    254258
    255 forall( type T | { int ?<?( T, T ); } )
     259forall( otype T | { int ?<?( T, T ); } )
    256260T min( const T t1, const T t2 ) {
    257261        return t1 < t2 ? t1 : t2;
    258262} // min
    259263
    260 forall( type T | { int ?>?( T, T ); } )
     264forall( otype T | { int ?>?( T, T ); } )
    261265T max( const T t1, const T t2 ) {
    262266        return t1 > t2 ? t1 : t2;
    263267} // max
    264268
    265 forall( type T )
     269forall( otype T )
    266270void swap( T * t1, T * t2 ) {
    267271        T temp = *t1;
Note: See TracChangeset for help on using the changeset viewer.