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 *new, *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->next = test_groups;
  99       strcpy(new->name, name);
 100       test_groups = new;
 101    } else {
 102       cur = test_groups;
 103       if (!cur) terrx("no current test group");
 104
 105       newt = malloc(sizeof(struct TestItem));
 106       if (!newt) terr("malloc");
 107
 108       newt->next = cur->tests;
 109       strcpy(newt->name, name);
 110       cur->tests = newt;
 111    }
 112 }
 113
 114 void InsertNameAndTypeIntoTestList( char *name, TestType type )
 115 {
 116     if ( !NameAndTypeInTestList( name, type ) )
 117         AppendToTestList( name, type );
 118 }
 119
 120 int CharacterIsDigit(char ch)
 121 {
 122     return ( ( ch >= '0') && ( ch <= '9' ) );
 123 }
 124
 125 int CharacterIsUppercase(char ch)
 126 {
 127     return ( ( ch >= 'A' ) && ( ch <= 'Z' ) );
 128 }
 129
 130 int CharacterIsLowercase(char ch)
 131 {
 132     return ( ( ch >= 'a' ) && ( ch <= 'z' ) );
 133 }
 134
 135 int CharacterIsAlphabetic(char ch)
 136 {
 137     return CharacterIsUppercase(ch) || CharacterIsLowercase(ch) || ( ch == '_' );
 138 }
 139
 140 int CharacterIsAlphanumeric( char ch )
 141 {
 142     return CharacterIsDigit(ch) || CharacterIsAlphabetic(ch);
 143 }
 144
 145 void ProcessGenericFunction( char *line, int position,
 146                             TestType type, int tokenDisplacement )
 147 {
 148     char name[MAX_SYMBOL_LENGTH] = "";
 149     int maxLength = strlen( line ) - 1, offset=0;
 150     position = position + tokenDisplacement;
 151
 152     while ( CharacterIsAlphanumeric(line[position])
 153        && (position<maxLength) && (offset<MAX_SYMBOL_LENGTH) )
 154     {
 155         name[offset++] = line[position++];
 156         name[offset] = 0;
 157     }
 158
 159     InsertNameAndTypeIntoTestList( name, type );
 160 }
 161
 162 void ProcessBringupFunction( char *line, int position )
 163 {
 164     ProcessGenericFunction( line, position, TYPE_BRINGUP, SEARCH_TOKEN_BRINGUP_LENGTH );
 165 }
 166
 167 void ProcessTestFunction( char *line, int position )
 168 {
 169     ProcessGenericFunction( line, position, TYPE_TEST, SEARCH_TOKEN_TEST_LENGTH );
 170 }
 171
 172
 173 int OffsetOfSubstring( char *line, char *token )
 174 {
 175     char *inset = strstr(line,token);
 176
 177     if ( !inset ) return -1;
 178     else return inset - line;
 179 }
 180
 181 void CallIfSubstringFound( char *line, char *token, void (*function)(char*,int) )
 182 {
 183     int index = OffsetOfSubstring( line, token );
 184     if ( index != -1 )
 185         function( line, index );
 186 }
 187
 188 void ProcessSourceFile( char *filename )
 189 {
 190    FILE *source;
 191    char line[MAX_LINE_LENGTH];
 192
 193    if( strcmp( filename, DO_NOT_PROCESS ) != 0 )
 194    {
 195
 196       source = fopen(filename,"r");
 197
 198       while ( fgets(line,MAX_LINE_LENGTH,source) )
 199       {
 200          CallIfSubstringFound( line, SEARCH_TOKEN_BRINGUP, ProcessBringupFunction );
 201          CallIfSubstringFound( line, SEARCH_TOKEN_TEST, ProcessTestFunction );
 202       }
 203
 204       fclose(source);
 205    }
 206 }
 207
 208 void EmitExternDeclarationFor( char *name, char *prefix )
 209 {
 210     fprintf( outfile, "extern void %s%s( void );\n", prefix, name );
 211 }
 212
 213 void Emit(char *text)
 214 {
 215    fprintf(outfile, "%s\n", text);
 216 }
 217
 218 void BlankLine()
 219 {
 220     Emit( "" );
 221 }
 222
 223 void ListExternalFunctions()
 224 {
 225    TestGroup *cur;
 226    TestItem *item;
 227
 228    for (cur = test_groups; cur; cur = cur->next) {
 229        EmitExternDeclarationFor(cur->name, SEARCH_TOKEN_BRINGUP);
 230        EmitExternDeclarationFor(cur->name, SEARCH_TOKEN_TAKEDOWN);
 231        for (item = cur->tests; item; item = item->next) {
 232           EmitExternDeclarationFor(item->name, SEARCH_TOKEN_TEST);
 233        }
 234    }
 235    BlankLine();
 236 }
 237
 238 void ListHeaderFiles(void)
 239 {
 240     Emit(
 241         "#include <string.h>\n"
 242         "#include <stdlib.h>\n"
 243         "#include <stdio.h>\n"
 244         "#include <stdarg.h>\n"
 245         "#include \"cut.h\"\n"
 246     );
 247     BlankLine();
 248     BlankLine();
 249 }
 250
 251 void EmitIndented(int indent,char *format, ...)
 252 {
 253    va_list v;
 254    /* Print two spaces per level of indentation. */
 255    fprintf( outfile, "%*s", indent*2, "" );
 256
 257    va_start(v,format);
 258    vfprintf( outfile, format, v );
 259    va_end(v);
 260
 261    fprintf( outfile, "\n" );
 262 }
 263
 264 void EmitUnitTesterBody()
 265 {
 266     TestItem *test;
 267     TestGroup *group;
 268
 269     Emit( "int main( int argc, char *argv[] )\n{" );
 270     Emit( "  if ( argc == 1 )" );
 271     Emit( "    cut_init(argv[0], -1 );" );
 272     Emit( "  else cut_init(argv[0], atoi( argv[1] ) );" );
 273     BlankLine();
 274
 275     for (group = test_groups; group; group = group->next) {
 276        for (test = group->tests; test; test = test->next) {
 277           EmitIndented(1, "cut_run(%s, %s);", group->name, test->name);
 278        }
 279     }
 280
 281     BlankLine();
 282     Emit( "  cut_exit();\n" );
 283     Emit( "  return 0;\n}\n" );
 284 }
 285
 286 void EmitCutCheck()
 287 {
 288     Emit( "/* Automatically generated: DO NOT MODIFY. */" );
 289     ListHeaderFiles();
 290     BlankLine();
 291     ListExternalFunctions();
 292     BlankLine();
 293     EmitUnitTesterBody();
 294 }
 295
 296 void FileName( char *base )
 297 {
 298     strncpy( g_fileName, base, MAX_LINE_LENGTH );
 299     g_fileName[ MAX_LINE_LENGTH - 1 ] = 0;
 300 }
 301
 302 int LoadArgument( void )
 303 {
 304    if ( g_index >= g_count )
 305       return 0;
 306
 307    FileName( g_wildcards[g_index] );
 308    g_index++;  /* MUST come after FileName() call; bad code smell */
 309    return 1;
 310 }
 311
 312 void StartArguments( int starting, int count, char *array[] )
 313 {
 314    g_index = starting;
 315    g_count = count;
 316    g_wildcards = array;
 317
 318    g_ready = LoadArgument();
 319 }
 320
 321 int NextArgument( void )
 322 {
 323    if( g_ready )
 324       g_ready = LoadArgument();
 325
 326    return g_ready;
 327 }
 328
 329 char *GetArgument( void )
 330 {
 331    if( g_ready )
 332       return g_fileName;
 333
 334    return NULL;
 335 }
 336
 337 void EstablishOutputFile( int argc, char *argv[] )
 338 {
 339    int i;
 340
 341    i = 0;
 342    while( i < argc )
 343    {
 344       if( ( argv[i+1] != NULL ) && ( strcmp( argv[i], "-o" ) == 0 ) )
 345       {
 346          outfile = fopen( argv[i+1], "wb+" );
 347          if( outfile == NULL )
 348             fprintf( stderr, "ERROR: Can't open %s for writing.\n", argv[i+1] );
 349
 350          argv[i] = argv[i+1] = DO_NOT_PROCESS;
 351
 352          return;
 353       }
 354
 355       i++;
 356    }
 357
 358    outfile = stdout;
 359 }
 360
 361 int main( int argc,char *argv[] )
 362 {
 363    char *filename;
 364
 365    if ( argc < 2 )
 366    {
 367       fprintf(
 368               stderr,
 369               "USAGE:\n"
 370               "   %s [options] <input file> [<input file> [...]]\n"
 371               "\n"
 372               "OPTIONS:\n"
 373               "   -o filename   Specifies output file.\n"
 374               "\n"
 375               "NOTES:\n"
 376               "   If -o is left unspecified, output defaults to stdout.\n",
 377               argv[0]
 378              );
 379       return 3;
 380    }
 381
 382    EstablishOutputFile( argc, argv );
 383
 384    /* Skip the executable's name and the output filename. */
 385    StartArguments(0,argc,argv);
 386
 387    /* Consume the rest of the arguments, one at a time. */
 388    while ( NextArgument() )
 389    {
 390       filename = GetArgument();
 391
 392       if( strcmp( filename, DO_NOT_PROCESS ) )
 393       {
 394          fprintf( stderr, "  - parsing '%s'... ", filename);
 395          ProcessSourceFile( filename );
 396          fprintf( stderr, "done.\n");
 397       }
 398    }
 399
 400    EmitCutCheck();
 401    fflush(outfile);
 402    fclose(outfile);
 403    return 0;
 404 }
 405
 406 /*
 407  * vim: tabstop=3 shiftwidth=3 expandtab
 408  */
 409