Changes in / [badd22f:62502cc4]


Ignore:
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • driver/cc1.cc

    rbadd22f r62502cc4  
    1010// Created On       : Fri Aug 26 14:23:51 2005
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 13 21:03:15 2020
    13 // Update Count     : 407
     12// Last Modified On : Sat May 30 18:09:05 2020
     13// Update Count     : 404
    1414//
    1515
     
    170170                        if ( arg == "-quiet" ) {
    171171                        } else if ( arg == "-imultilib" || arg == "-imultiarch" ) {
    172                                 i += 1;                                                                 // and argument
     172                                i += 1;                                                                 // and the argument
    173173                        } else if ( prefix( arg, "-A" ) ) {
    174174                        } else if ( prefix( arg, "-D__GNU" ) ) {
     
    177177                                //********
    178178                        } else if ( arg == "-D" && prefix( argv[i + 1], "__GNU" ) ) {
    179                                 i += 1;                                                                 // and argument
     179                                i += 1;                                                                 // and the argument
    180180
    181181                                // strip flags controlling cpp step
     
    184184                                cpp_flag = true;
    185185                        } else if ( arg == "-D" && string( argv[i + 1] ) == "__CPP__" ) {
    186                                 i += 1;                                                                 // and argument
     186                                i += 1;                                                                 // and the argument
    187187                                cpp_flag = true;
    188188
     
    194194                                cpp_out = argv[i];
    195195                        } else {
    196                                 args[nargs++] = argv[i];                                // pass flag along
     196                                args[nargs++] = argv[i];                                // pass the flag along
    197197                                // CPP flags with an argument
    198198                                if ( arg == "-D" || arg == "-U" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" ||
     
    200200                                         arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) {
    201201                                        i += 1;
    202                                         args[nargs++] = argv[i];                        // pass argument along
     202                                        args[nargs++] = argv[i];                        // pass the argument along
    203203                                        #ifdef __DEBUG_H__
    204204                                        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
    205205                                        #endif // __DEBUG_H__
    206206                                } else if ( arg == "-MD" || arg == "-MMD" ) {
    207                                         // gcc frontend generates the dependency file-name after the -MD/-MMD flag, but it is necessary to
    208                                         // prefix that file name with -MF.
    209207                                        args[nargs++] = "-MF";                          // insert before file
    210208                                        i += 1;
    211                                         args[nargs++] = argv[i];                        // pass argument along
     209                                        args[nargs++] = argv[i];                        // pass the argument along
    212210                                        #ifdef __DEBUG_H__
    213211                                        cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
     
    281279        // Run the C preprocessor and save the output in the given file.
    282280
    283         if ( fork() == 0 ) {                                                            // child process ?
     281        if ( fork() == 0 ) {                                                             // child process ?
    284282                // -o xxx.ii cannot be used to write the output file from cpp because no output file is created if cpp detects
    285283                // an error (e.g., cannot find include file). Whereas, output is always generated, even when there is an error,
     
    390388
    391389                        } else {
    392                                 args[nargs++] = argv[i];                                // pass flag along
     390                                args[nargs++] = argv[i];                                // pass the flag along
    393391                                if ( arg == "-o" ) {
    394392                                        i += 1;
    395393                                        cpp_out = argv[i];
    396                                         args[nargs++] = argv[i];                        // pass argument along
     394                                        args[nargs++] = argv[i];                        // pass the argument along
    397395                                        #ifdef __DEBUG_H__
    398396                                        cerr << "arg:\"" << argv[i] << "\"" << endl;
  • driver/cfa.cc

    rbadd22f r62502cc4  
    1010// Created On       : Tue Aug 20 13:44:49 2002
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 13 17:22:02 2020
    13 // Update Count     : 435
     12// Last Modified On : Sat May 30 18:28:23 2020
     13// Update Count     : 433
    1414//
    1515
     
    180180
    181181                        if ( arg == "-Xlinker" || arg == "-o" ) {
    182                                 args[nargs++] = argv[i];                                // pass flag along
     182                                args[nargs++] = argv[i];                                // pass argument along
    183183                                i += 1;
    184184                                if ( i == argc ) continue;                              // next argument available ?
    185185                                args[nargs++] = argv[i];                                // pass argument along
    186186                                if ( arg == "-o" ) o_file = i;                  // remember file
    187                         } else if ( strncmp(arg.c_str(), "-XCFA", 5) == 0 ) { // CFA pass through
    188                                 if ( arg.size() == 5 ) {
     187                        } else if ( strncmp(arg.c_str(), "-XCFA", 5) == 0 ) {                           // CFA pass through
     188                                if(arg.size() == 5) {
    189189                                        i += 1;
    190                                         if ( i == argc ) continue;                      // next argument available ?
     190                                        if ( i == argc ) continue;                              // next argument available ?
    191191                                        Putenv( argv, argv[i] );
    192                                 } else if ( arg[5] == ',' ) {                   // CFA specific arguments
     192
     193                                        // CFA specific arguments
     194                                }
     195                                else if(arg[5] == ',') {
    193196                                        Putenv( argv, argv[i] + 6 );
    194                                 } else {                                                                // CFA specific arguments
     197
     198                                        // CFA specific arguments
     199                                }
     200                                else {
    195201                                        args[nargs++] = argv[i];
    196                                 } // if
     202                                }
     203
    197204                        } else if ( arg == "-CFA" ) {
    198205                                CFA_flag = true;                                                // strip the -CFA flag
     
    228235                        } else if ( arg == "-v" ) {
    229236                                verbose = true;                                                 // verbosity required
    230                                 args[nargs++] = argv[i];                                // pass flag along
     237                                args[nargs++] = argv[i];                                // pass argument along
    231238                        } else if ( arg == "-g" ) {
    232239                                debugging = true;                                               // symbolic debugging required
    233                                 args[nargs++] = argv[i];                                // pass flag along
     240                                args[nargs++] = argv[i];                                // pass argument along
    234241                        } else if ( arg == "-save-temps" ) {
    235                                 args[nargs++] = argv[i];                                // pass flag along
     242                                args[nargs++] = argv[i];                                // pass argument along
    236243                                Putenv( argv, arg );                                    // save cfa-cpp output
    237244                        } else if ( prefix( arg, "-x" ) ) {                     // file suffix ?
    238245                                string lang;
    239                                 args[nargs++] = argv[i];                                // pass flag along
     246                                args[nargs++] = argv[i];                                // pass argument along
    240247                                if ( arg.length() == 2 ) {                              // separate argument ?
    241248                                        i += 1;
     
    254261                        } else if ( prefix( arg, "-std=" ) || prefix( arg, "--std=" ) ) {
    255262                                std_flag = true;                                                // -std=XX provided
    256                                 args[nargs++] = argv[i];                                // pass flag along
     263                                args[nargs++] = argv[i];                                // pass argument along
    257264                        } else if ( arg == "-w" ) {
    258                                 args[nargs++] = argv[i];                                // pass flag along
     265                                args[nargs++] = argv[i];                                // pass argument along
    259266                                Putenv( argv, arg );
    260267                        } else if ( prefix( arg, "-W" ) ) {                     // check before next tests
    261268                                if ( arg == "-Werror" || arg == "-Wall" ) {
    262                                         args[nargs++] = argv[i];                        // pass flag along
     269                                        args[nargs++] = argv[i];                        // pass argument along
    263270                                        Putenv( argv, argv[i] );
    264271                                } else {
     
    274281                                bprefix = arg.substr(2);                                // strip the -B flag
    275282                        } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
    276                                 args[nargs++] = argv[i];                                // pass flag along
     283                                args[nargs++] = argv[i];                                // pass argument along
    277284                                if ( arg == "-E" || arg == "-M" || arg == "-MM" ) {
    278285                                        cpp_flag = true;                                        // cpp only
    279286                                } // if
    280287                                link = false;                           // no linkage required
    281                         } else if ( arg == "-D" || arg == "-U" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" ||
    282                                                 arg == "-include" || arg == "-imacros" || arg == "-idirafter" || arg == "-iprefix" ||
    283                                                 arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) {
    284                                 args[nargs++] = argv[i];                                // pass flag along
    285                                 i += 1;
    286                                 args[nargs++] = argv[i];                                // pass argument along
    287288                        } else if ( arg[1] == 'l' ) {
    288289                                // if the user specifies a library, load it after user code
  • libcfa/src/iostream.cfa

    rbadd22f r62502cc4  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug 11 22:16:33 2020
    13 // Update Count     : 1128
     12// Last Modified On : Mon Aug 10 09:32:14 2020
     13// Update Count     : 1126
    1414//
    1515
     
    3737
    3838forall( dtype ostype | ostream( ostype ) ) {
     39        ostype & ?|?( ostype & os, zero_t ) {
     40                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     41                fmt( os, "%d", 0n );
     42                return os;
     43        } // ?|?
     44        void ?|?( ostype & os, zero_t z ) {
     45                (ostype &)(os | z); ends( os );
     46        } // ?|?
     47
     48        ostype & ?|?( ostype & os, one_t ) {
     49                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
     50                fmt( os, "%d", 1n );
     51                return os;
     52        } // ?|?
     53        void ?|?( ostype & os, one_t o ) {
     54                (ostype &)(os | o); ends( os );
     55        } // ?|?
     56
    3957        ostype & ?|?( ostype & os, bool b ) {
    4058                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
  • libcfa/src/iostream.hfa

    rbadd22f r62502cc4  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug 11 22:16:14 2020
    13 // Update Count     : 350
     12// Last Modified On : Thu Jul 16 07:43:32 2020
     13// Update Count     : 348
    1414//
    1515
     
    6767
    6868forall( dtype ostype | ostream( ostype ) ) {
     69        ostype & ?|?( ostype &, zero_t );
     70        void ?|?( ostype &, zero_t );
     71        ostype & ?|?( ostype &, one_t );
     72        void ?|?( ostype &, one_t );
     73
    6974        ostype & ?|?( ostype &, bool );
    7075        void ?|?( ostype &, bool );
  • libcfa/src/stdlib.hfa

    rbadd22f r62502cc4  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug 11 21:11:46 2020
    13 // Update Count     : 495
     12// Last Modified On : Thu Jul 30 16:14:58 2020
     13// Update Count     : 490
    1414//
    1515
     
    136136        T * alloc_set( char fill ) {
    137137                return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
    138         } // alloc_set
    139 
    140         T * alloc_set( const T & fill ) {
     138        } // alloc
     139
     140        T * alloc_set( T fill ) {
    141141                return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
    142         } // alloc_set
     142        } // alloc
    143143
    144144        T * alloc_set( size_t dim, char fill ) {
    145145                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
    146         } // alloc_set
    147 
    148         T * alloc_set( size_t dim, const T & fill ) {
     146        } // alloc
     147
     148        T * alloc_set( size_t dim, T fill ) {
    149149                T * r = (T *)alloc( dim );
    150150                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
    151151                return r;
    152         } // alloc_set
     152        } // alloc
    153153
    154154        T * alloc_set( size_t dim, const T fill[] ) {
    155155                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
    156         } // alloc_set
     156        } // alloc
    157157
    158158        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
     
    166166        } // alloc_set
    167167
    168         T * alloc_set( T ptr[], size_t dim, const T & fill ) {  // realloc array with fill
     168        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
    169169                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
    170170                size_t nsize = dim * sizeof(T);                                 // new allocation
     
    177177                } // if
    178178                return nptr;
    179         } // alloc_set
     179        } // alloc_align_set
    180180} // distribution
    181181
     
    204204        T * alloc_align_set( size_t align, char fill ) {
    205205                return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
    206         } // alloc_align_set
    207 
    208         T * alloc_align_set( size_t align, const T & fill ) {
     206        } // alloc_align
     207
     208        T * alloc_align_set( size_t align, T fill ) {
    209209                return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
    210         } // alloc_align_set
     210        } // alloc_align
    211211
    212212        T * alloc_align_set( size_t align, size_t dim, char fill ) {
    213213                return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
    214         } // alloc_align_set
    215 
    216         T * alloc_align_set( size_t align, size_t dim, const T & fill ) {
     214        } // alloc_align
     215
     216        T * alloc_align_set( size_t align, size_t dim, T fill ) {
    217217                T * r = (T *)alloc_align( align, dim );
    218218                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
    219219                return r;
    220         } // alloc_align_set
     220        } // alloc_align
    221221
    222222        T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
    223223                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
    224         } // alloc_align_set
     224        } // alloc_align
    225225
    226226        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
     
    234234        } // alloc_align_set
    235235
    236         T * alloc_align_set( T ptr[], size_t align, size_t dim, const T & fill ) {
     236        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
    237237                size_t odim = malloc_size( ptr ) / sizeof(T);   // current dimension
    238238                size_t nsize = dim * sizeof(T);                                 // new allocation
Note: See TracChangeset for help on using the changeset viewer.