Changeset 90c3b1c for src/libcfa


Ignore:
Timestamp:
Mar 2, 2016, 4:59:19 PM (9 years ago)
Author:
Peter A. Buhr <pabuhr@…>
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:
bdad1679
Parents:
ac1ed49
Message:

compile CFA with C++11, further update refrat with lstlisting macros, support varags, enumeration initialization, add implicit separators to output streams, update example programs that print

Location:
src/libcfa
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/Makefile.in

    rac1ed49 r90c3b1c  
    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

    rac1ed49 r90c3b1c  
    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

    rac1ed49 r90c3b1c  
    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

    rac1ed49 r90c3b1c  
    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

    rac1ed49 r90c3b1c  
    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 16:44:32 2016
     13// Update Count     : 81
    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 
    2321context 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};
     36
    2837context writeable( type T ) {
    2938        forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
    … …  
    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
    … …  
    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
    … …  
    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

    rac1ed49 r90c3b1c  
    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 16:20:57 2016
     13// Update Count     : 207
    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( type elttype | writeable( elttype ), type 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( type elttype | writeable( elttype ), type 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/stdlib

    rac1ed49 r90c3b1c  
    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 16:52:25 2016
     13// Update Count     : 63
    1414//
    1515
    … …  
    2525forall( type T ) T * malloc( void );
    2626forall( type T ) T * malloc( char fill );
    27 forall( type T ) T * malloc( size_t size );
    2827forall( type T ) T * malloc( T * ptr, size_t size );
    2928forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill );

  • src/libcfa/stdlib.c

    rac1ed49 r90c3b1c  
    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 : Tue Feb 23 21:02:54 2016
     13// Update Count     : 142
    1414//
    1515
    … …  
    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;
Note: See TracChangeset for help on using the changeset viewer.