cutgen.c

   1 /*
   2  * This file has been modified from the original CUT distribution.
   3  *
   4  * CUT 2.3-kr1
   5  * Copyright (c) 2001-2002 Samuel A. Falvo II, William D. Tanksley
   6  * See CUT-LICENSE.TXT for details.
   7  *
   8  * $Log: cutgen.c,v $
   9  * Revision 1.4  2003/03/18 05:53:50  sfalvo
  10  * ADD: cutgen.c: cut_exit() -- common exit point; returns proper error code
  11  * at all times.
  12  *
  13  * FIX: cutgen.c: Factored all instances of exit() to invoke cut_exit()
  14  * instead.  This fixes the bug #703793.
  15  *
  16  * Revision 1.3  2003/03/13 04:27:54  sfalvo
  17  * ADD: LICENSE.TXT -- zlib license
  18  *
  19  * ADD: README cut.h cutgen.c -- Changelog token for CVS
  20  *
  21  * FIX: test/bringup-failure -- reflects new usage for bringups and
  22  * teardowns in CUT 2.2.
  23  *
  24  */
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30
  31 #include "util.h"
  32
  33 #define DO_NOT_PROCESS        "..."
  34
  35 #define SEARCH_TOKEN_TEST     "__CUT__"
  36 #define SEARCH_TOKEN_BRINGUP  "__CUT_BRINGUP__"
  37 #define SEARCH_TOKEN_TAKEDOWN "__CUT_TAKEDOWN__"
  38
  39 #define MAX_SYMBOL_LENGTH 256  /* arbitrary */
  40 #define MAX_LINE_LENGTH   1024 /* arbitrary */
  41
  42 #define SEARCH_TOKEN_TEST_LENGTH       sizeof( SEARCH_TOKEN_TEST )-1
  43 #define SEARCH_TOKEN_BRINGUP_LENGTH    sizeof( SEARCH_TOKEN_BRINGUP )-1
  44
  45 #define terr(fmt, args...) do { fprintf(stderr, "\n"); twarn(fmt, ##args); exit(1); } while (0)
  46 #define terrx(fmt, args...) do { fprintf(stderr, "\n"); twarnx(fmt, ##args); exit(1); } while (0)
  47
  48 typedef enum TestType {
  49    TYPE_TEST = 0,
  50    TYPE_BRINGUP = 1,
  51 } TestType;
  52
  53 typedef struct TestItem {
  54    char name[MAX_SYMBOL_LENGTH];
  55    struct TestItem *next;
  56 } TestItem;
  57
  58 typedef struct TestGroup {
  59    char name[MAX_SYMBOL_LENGTH];
  60    struct TestItem *tests;
  61    struct TestGroup *next;
  62 } TestGroup;
  63
  64 /* globals */
  65
  66 TestGroup *test_groups = 0;
  67 FILE *outfile;
  68
  69 static int g_count, g_ready, g_index;  /* Used by filename globbing support for windows */
  70 static char **g_wildcards, g_fileName[MAX_LINE_LENGTH];
  71
  72 int NameAndTypeInTestList( char *name, TestType type )
  73 {
  74    TestItem *item;
  75    TestGroup *group;
  76
  77    for (group = test_groups; group; group = group->next) {
  78       if (!strcmp(group->name, name) && type == TYPE_BRINGUP) return 1;
  79       for (item = group->tests; item; item = item->next) {
  80          if (!strcmp(item->name, name)) return 1;
  81       }
  82    }
  83
  84    return 0;
  85 }
  86
  87 void AppendToTestList( char *name, TestType type )
  88 {
  89    TestGroup *cur;
  90    TestItem *newt;
  91
  92    if (type == TYPE_BRINGUP) {
  93       struct TestGroup *new;
  94
  95       new = malloc(sizeof(struct TestGroup));
  96       if (!new) terr("malloc");
  97
  98       new->tests = 0;
  99       new->next = test_groups;
 100       strcpy(new->name, name);
 101       test_groups = new;
 102    } else {
 103       cur = test_groups;
 104       if (!cur) terrx("no current test group");
 105
 106       newt = malloc(sizeof(struct TestItem));
 107       if (!newt) terr("malloc");
 108
 109       newt->next = cur->tests;
 110       strcpy(newt->name, name);
 111       cur->tests = newt;
 112    }
 113 }
 114
 115 void InsertNameAndTypeIntoTestList( char *name, TestType type )
 116 {
 117     if ( !NameAndTypeInTestList( name, type ) )
 118         AppendToTestList( name, type );
 119 }
 120
 121 int CharacterIsDigit(char ch)
 122 {
 123     return ( ( ch >= '0') && ( ch <= '9' ) );
 124 }
 125
 126 int CharacterIsUppercase(char ch)
 127 {
 128     return ( ( ch >= 'A' ) && ( ch <= 'Z' ) );
 129 }
 130
 131 int CharacterIsLowercase(char ch)
 132 {
 133     return ( ( ch >= 'a' ) && ( ch <= 'z' ) );
 134 }
 135
 136 int CharacterIsAlphabetic(char ch)
 137 {
 138     return CharacterIsUppercase(ch) || CharacterIsLowercase(ch) || ( ch == '_' );
 139 }
 140
 141 int CharacterIsAlphanumeric( char ch )
 142 {
 143     return CharacterIsDigit(ch) || CharacterIsAlphabetic(ch);
 144 }
 145
 146 void ProcessGenericFunction( char *line, int position,
 147                             TestType type, int tokenDisplacement )
 148 {
 149     char name[MAX_SYMBOL_LENGTH] = "";
 150     int maxLength = strlen( line ) - 1, offset=0;
 151     position = position + tokenDisplacement;
 152
 153     while ( CharacterIsAlphanumeric(line[position])
 154        && (position<maxLength) && (offset<MAX_SYMBOL_LENGTH) )
 155     {
 156         name[offset++] = line[position++];
 157         name[offset] = 0;
 158     }
 159
 160     InsertNameAndTypeIntoTestList( name, type );
 161 }
 162
 163 void ProcessBringupFunction( char *line, int position )
 164 {
 165     ProcessGenericFunction( line, position, TYPE_BRINGUP, SEARCH_TOKEN_BRINGUP_LENGTH );
 166 }
 167
 168 void ProcessTestFunction( char *line, int position )
 169 {
 170     ProcessGenericFunction( line, position, TYPE_TEST, SEARCH_TOKEN_TEST_LENGTH );
 171 }
 172
 173
 174 int OffsetOfSubstring( char *line, char *token )
 175 {
 176     char *inset = strstr(line,token);
 177
 178     if ( !inset ) return -1;
 179     else return inset - line;
 180 }
 181
 182 void CallIfSubstringFound( char *line, char *token, void (*function)(char*,int) )
 183 {
 184     int index = OffsetOfSubstring( line, token );
 185     if ( index != -1 )
 186         function( line, index );
 187 }
 188
 189 void ProcessSourceFile( char *filename )
 190 {
 191    FILE *source;
 192    char line[MAX_LINE_LENGTH];
 193
 194    if( strcmp( filename, DO_NOT_PROCESS ) != 0 )
 195    {
 196
 197       source = fopen(filename,"r");
 198
 199       while ( fgets(line,MAX_LINE_LENGTH,source) )
 200       {
 201          CallIfSubstringFound( line, SEARCH_TOKEN_BRINGUP, ProcessBringupFunction );
 202          CallIfSubstringFound( line, SEARCH_TOKEN_TEST, ProcessTestFunction );
 203       }
 204
 205       fclose(source);
 206    }
 207 }
 208
 209 void EmitExternDeclarationFor( char *name, char *prefix )
 210 {
 211     fprintf( outfile, "extern void %s%s( void );\n", prefix, name );
 212 }
 213
 214 void Emit(char *text)
 215 {
 216    fprintf(outfile, "%s\n", text);
 217 }
 218
 219 void BlankLine()
 220 {
 221     Emit( "" );
 222 }
 223
 224 void ListExternalFunctions()
 225 {
 226    TestGroup *cur;
 227    TestItem *item;
 228
 229    for (cur = test_groups; cur; cur = cur->next) {
 230        EmitExternDeclarationFor(cur->name, SEARCH_TOKEN_BRINGUP);
 231        EmitExternDeclarationFor(cur->name, SEARCH_TOKEN_TAKEDOWN);
 232        for (item = cur->tests; item; item = item->next) {
 233           EmitExternDeclarationFor(item->name, SEARCH_TOKEN_TEST);
 234        }
 235    }
 236    BlankLine();
 237 }
 238
 239 void ListHeaderFiles(void)
 240 {
 241     Emit(
 242         "#include <string.h>\n"
 243         "#include <stdlib.h>\n"
 244         "#include <stdio.h>\n"
 245         "#include <stdarg.h>\n"
 246         "#include \"cut.h\"\n"
 247     );
 248     BlankLine();
 249     BlankLine();
 250 }
 251
 252 void EmitIndented(int indent,char *format, ...)
 253 {
 254    va_list v;
 255    /* Print two spaces per level of indentation. */
 256    fprintf( outfile, "%*s", indent*2, "" );
 257
 258    va_start(v,format);
 259    vfprintf( outfile, format, v );
 260    va_end(v);
 261
 262    fprintf( outfile, "\n" );
 263 }
 264
 265 void EmitUnitTesterBody()
 266 {
 267     TestItem *test;
 268     TestGroup *group;
 269
 270     Emit( "int main( int argc, char *argv[] )\n{" );
 271     Emit( "  if ( argc == 1 )" );
 272     Emit( "    cut_init(argv[0], -1 );" );
 273     Emit( "  else cut_init(argv[0], atoi( argv[1] ) );" );
 274     BlankLine();
 275
 276     for (group = test_groups; group; group = group->next) {
 277        for (test = group->tests; test; test = test->next) {
 278           EmitIndented(1, "cut_run(%s, %s);", group->name, test->name);
 279        }
 280     }
 281
 282     BlankLine();
 283     Emit( "  cut_exit();\n" );
 284     Emit( "  return 0;\n}\n" );
 285 }
 286
 287 void EmitCutCheck()
 288 {
 289     Emit( "/* Automatically generated: DO NOT MODIFY. */" );
 290     ListHeaderFiles();
 291     BlankLine();
 292     ListExternalFunctions();
 293     BlankLine();
 294     EmitUnitTesterBody();
 295 }
 296
 297 void FileName( char *base )
 298 {
 299     strncpy( g_fileName, base, MAX_LINE_LENGTH );
 300     g_fileName[ MAX_LINE_LENGTH - 1 ] = 0;
 301 }
 302
 303 int LoadArgument( void )
 304 {
 305    if ( g_index >= g_count )
 306       return 0;
 307
 308    FileName( g_wildcards[g_index] );
 309    g_index++;  /* MUST come after FileName() call; bad code smell */
 310    return 1;
 311 }
 312
 313 void StartArguments( int starting, int count, char *array[] )
 314 {
 315    g_index = starting;
 316    g_count = count;
 317    g_wildcards = array;
 318
 319    g_ready = LoadArgument();
 320 }
 321
 322 int NextArgument( void )
 323 {
 324    if( g_ready )
 325       g_ready = LoadArgument();
 326
 327    return g_ready;
 328 }
 329
 330 char *GetArgument( void )
 331 {
 332    if( g_ready )
 333       return g_fileName;
 334
 335    return NULL;
 336 }
 337
 338 void EstablishOutputFile( int argc, char *argv[] )
 339 {
 340    int i;
 341
 342    i = 0;
 343    while( i < argc )
 344    {
 345       if( ( argv[i+1] != NULL ) && ( strcmp( argv[i], "-o" ) == 0 ) )
 346       {
 347          outfile = fopen( argv[i+1], "wb+" );
 348          if( outfile == NULL )
 349             fprintf( stderr, "ERROR: Can't open %s for writing.\n", argv[i+1] );
 350
 351          argv[i] = argv[i+1] = DO_NOT_PROCESS;
 352
 353          return;
 354       }
 355
 356       i++;
 357    }
 358
 359    outfile = stdout;
 360 }
 361
 362 int main( int argc,char *argv[] )
 363 {
 364    char *filename;
 365
 366    if ( argc < 2 )
 367    {
 368       fprintf(
 369               stderr,
 370               "USAGE:\n"
 371               "   %s [options] <input file> [<input file> [...]]\n"
 372               "\n"
 373               "OPTIONS:\n"
 374               "   -o filename   Specifies output file.\n"
 375               "\n"
 376               "NOTES:\n"
 377               "   If -o is left unspecified, output defaults to stdout.\n",
 378               argv[0]
 379              );
 380       return 3;
 381    }
 382
 383    EstablishOutputFile( argc, argv );
 384
 385    /* Skip the executable's name and the output filename. */
 386    StartArguments(0,argc,argv);
 387
 388    /* Consume the rest of the arguments, one at a time. */
 389    while ( NextArgument() )
 390    {
 391       filename = GetArgument();
 392
 393       if( strcmp( filename, DO_NOT_PROCESS ) )
 394       {
 395          fprintf( stderr, "  - parsing '%s'... ", filename);
 396          ProcessSourceFile( filename );
 397          fprintf( stderr, "done.\n");
 398       }
 399    }
 400
 401    EmitCutCheck();
 402    fflush(outfile);
 403    fclose(outfile);
 404    return 0;
 405 }
 406
 407 /*
 408  * vim: tabstop=3 shiftwidth=3 expandtab
 409  */
 410