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 #define DO_NOT_PROCESS        "..."
  32
  33 #define SEARCH_TOKEN_TEST     "__CUT__"
  34 #define SEARCH_TOKEN_BRINGUP  "__CUT_BRINGUP__"
  35 #define SEARCH_TOKEN_TAKEDOWN "__CUT_TAKEDOWN__"
  36
  37 #define MAX_SYMBOL_LENGTH 256  /* arbitrary */
  38 #define MAX_LINE_LENGTH   1024 /* arbitrary */
  39
  40 #define SEARCH_TOKEN_TEST_LENGTH       sizeof( SEARCH_TOKEN_TEST )-1
  41 #define SEARCH_TOKEN_BRINGUP_LENGTH    sizeof( SEARCH_TOKEN_BRINGUP )-1
  42 #define SEARCH_TOKEN_TAKEDOWN_LENGTH   sizeof( SEARCH_TOKEN_TAKEDOWN )-1
  43
  44 typedef enum TestType {
  45    TYPE_TEST = 0,
  46    TYPE_BRINGUP = 1,
  47    TYPE_TAKEDOWN = 2
  48 } TestType;
  49
  50 typedef struct TestItem {
  51    char name[MAX_SYMBOL_LENGTH];
  52    enum TestType type;
  53    struct TestItem *next;
  54 } TestItem;
  55
  56 /* globals */
  57
  58 TestItem *testList = 0;
  59 FILE *outfile;
  60 extern char *libCUT[]; /* defined at the end of this file */
  61
  62 static int g_count, g_ready, g_index;  /* Used by filename globbing support for windows */
  63 static char **g_wildcards, g_fileName[MAX_LINE_LENGTH];
  64
  65 TestItem *FindFirstMatch( TestItem *current, char *basis_name, int basis_type )
  66 {
  67    while ( current )
  68    {
  69       if ( !strcmp(current->name,basis_name) && current->type == basis_type )
  70          return current;
  71       current = current->next;
  72    }
  73    return 0;
  74 }
  75
  76 int NameAndTypeInTestList( char *name, TestType type )
  77 {
  78    return 0 != FindFirstMatch(testList,name,type);
  79 }
  80
  81 void AppendToTestList( char *name, TestType type )
  82 {
  83    struct TestItem *current = testList;
  84    if ( !current )
  85       current = testList = malloc( sizeof( *testList) );
  86    else
  87    {
  88       while ( current->next ) current = current->next;
  89       current->next = malloc(sizeof( *testList));
  90       current = current->next;
  91    }
  92
  93    current->next = 0;
  94    strcpy(current->name, name);
  95    current->type = type;
  96 }
  97
  98 void InsertNameAndTypeIntoTestList( char *name, TestType type )
  99 {
 100     if ( !NameAndTypeInTestList( name, type ) )
 101         AppendToTestList( name, type );
 102 }
 103
 104 int CharacterIsDigit(char ch)
 105 {
 106     return ( ( ch >= '0') && ( ch <= '9' ) );
 107 }
 108
 109 int CharacterIsUppercase(char ch)
 110 {
 111     return ( ( ch >= 'A' ) && ( ch <= 'Z' ) );
 112 }
 113
 114 int CharacterIsLowercase(char ch)
 115 {
 116     return ( ( ch >= 'a' ) && ( ch <= 'z' ) );
 117 }
 118
 119 int CharacterIsAlphabetic(char ch)
 120 {
 121     return CharacterIsUppercase(ch) || CharacterIsLowercase(ch) || ( ch == '_' );
 122 }
 123
 124 int CharacterIsAlphanumeric( char ch )
 125 {
 126     return CharacterIsDigit(ch) || CharacterIsAlphabetic(ch);
 127 }
 128
 129 void ProcessGenericFunction( char *line, int position,
 130                             TestType type, int tokenDisplacement )
 131 {
 132     char name[MAX_SYMBOL_LENGTH] = "";
 133     int maxLength = strlen( line ) - 1, offset=0;
 134     position = position + tokenDisplacement;
 135
 136     while ( CharacterIsAlphanumeric(line[position])
 137        && (position<maxLength) && (offset<MAX_SYMBOL_LENGTH) )
 138     {
 139         name[offset++] = line[position++];
 140         name[offset] = 0;
 141     }
 142
 143     InsertNameAndTypeIntoTestList( name, type );
 144 }
 145
 146 void ProcessBringupFunction( char *line, int position )
 147 {
 148     ProcessGenericFunction( line, position, TYPE_BRINGUP, SEARCH_TOKEN_BRINGUP_LENGTH );
 149 }
 150
 151 void ProcessTestFunction( char *line, int position )
 152 {
 153     ProcessGenericFunction( line, position, TYPE_TEST, SEARCH_TOKEN_TEST_LENGTH );
 154 }
 155
 156 void ProcessTakedownFunction( char *line, int position )
 157 {
 158     ProcessGenericFunction( line, position, TYPE_TAKEDOWN, SEARCH_TOKEN_TAKEDOWN_LENGTH );
 159 }
 160
 161
 162 int OffsetOfSubstring( char *line, char *token )
 163 {
 164     char *inset = strstr(line,token);
 165
 166     if ( !inset ) return -1;
 167     else return inset - line;
 168 }
 169
 170 void CallIfSubstringFound( char *line, char *token, void (*function)(char*,int) )
 171 {
 172     int index = OffsetOfSubstring( line, token );
 173     if ( index != -1 )
 174         function( line, index );
 175 }
 176
 177 void ProcessSourceFile( char *filename )
 178 {
 179    FILE *source;
 180    char line[MAX_LINE_LENGTH];
 181
 182    if( strcmp( filename, DO_NOT_PROCESS ) != 0 )
 183    {
 184
 185       source = fopen(filename,"r");
 186
 187       while ( fgets(line,MAX_LINE_LENGTH,source) )
 188       {
 189          CallIfSubstringFound( line, SEARCH_TOKEN_BRINGUP, ProcessBringupFunction );
 190          CallIfSubstringFound( line, SEARCH_TOKEN_TEST, ProcessTestFunction );
 191          CallIfSubstringFound( line, SEARCH_TOKEN_TAKEDOWN, ProcessTakedownFunction );
 192       }
 193
 194       fclose(source);
 195    }
 196 }
 197
 198 void EmitExternDeclarationFor( char *name, char *prefix )
 199 {
 200     fprintf( outfile, "extern void %s%s( void );\n", prefix, name );
 201 }
 202
 203 void Emit(char *text)
 204 {
 205    fprintf(outfile, "%s\n", text);
 206 }
 207
 208 void BlankLine()
 209 {
 210     Emit( "" );
 211 }
 212
 213 void ListExternalFunctions()
 214 {
 215    TestItem *current = testList;
 216    while ( current )
 217    {
 218       if (current->type == TYPE_TEST)
 219          EmitExternDeclarationFor( current->name, SEARCH_TOKEN_TEST );
 220       else if (current->type == TYPE_BRINGUP)
 221          EmitExternDeclarationFor( current->name, SEARCH_TOKEN_BRINGUP );
 222       else if (current->type == TYPE_TAKEDOWN)
 223          EmitExternDeclarationFor( current->name, SEARCH_TOKEN_TAKEDOWN );
 224       current = current->next;
 225    }
 226
 227    BlankLine();
 228 }
 229
 230 void EmitLibrary(void)
 231 {
 232    int i=0;
 233    while ( libCUT[i] )
 234       Emit(libCUT[i++]);
 235 }
 236
 237 void ListHeaderFiles(void)
 238 {
 239     EmitLibrary();
 240     BlankLine();
 241     BlankLine();
 242 }
 243
 244 void EmitIndented(int indent,char *format, ...)
 245 {
 246    va_list v;
 247    /* Print two spaces per level of indentation. */
 248    fprintf( outfile, "%*s", indent*2, "" );
 249
 250    va_start(v,format);
 251    vfprintf( outfile, format, v );
 252    va_end(v);
 253
 254    fprintf( outfile, "\n" );
 255 }
 256
 257 void EmitBringup(int indent,char *name)
 258 {
 259     BlankLine();
 260     EmitIndented(indent, "cut_start( \"group-%s\", __CUT_TAKEDOWN__%s );",
 261            name, name );
 262     EmitIndented(indent, "__CUT_BRINGUP__%s();", name );
 263     EmitIndented(indent, "cut_check_errors();");
 264 }
 265
 266 void EmitTest(int indent,char *name)
 267 {
 268     EmitIndented(indent, "cut_start( \"%s\", 0 );", name );
 269     EmitIndented(indent, "__CUT__%s();", name );
 270     EmitIndented(indent, "cut_end( \"%s\" );", name );
 271 }
 272
 273 void EmitTakedown(int indent,char *name)
 274 {
 275     EmitIndented(indent, "cut_end( \"group-%s\" );", name );
 276     EmitIndented(indent, "__CUT_TAKEDOWN__%s();", name );
 277     BlankLine();
 278 }
 279
 280 void EmitUnitTesterBody()
 281 {
 282     int indent=0;
 283     TestItem *test;
 284     Emit( "int main( int argc, char *argv[] )\n{" );
 285     Emit( "  if ( argc == 1 )" );
 286     Emit( "    cut_init( -1 );" );
 287     Emit( "  else cut_init( atoi( argv[1] ) );" );
 288     BlankLine();
 289
 290     indent = 1;
 291     test = testList;
 292     while ( test )
 293     {
 294       if (test->type == TYPE_BRINGUP)
 295       {
 296          EmitBringup(indent,test->name);
 297          indent ++;
 298       }
 299
 300       if (test->type == TYPE_TEST)
 301          EmitTest(indent,test->name);
 302
 303       if (test->type == TYPE_TAKEDOWN)
 304       {
 305          indent --;
 306          EmitTakedown(indent,test->name);
 307       }
 308       test = test->next;
 309     }
 310
 311     BlankLine();
 312     Emit( "  cut_break_formatting();" );
 313     Emit( "  printf(\"Done.\\n\");" );
 314     Emit( "  return 0;\n}\n" );
 315 }
 316
 317 void EmitCutCheck()
 318 {
 319     Emit( "/* Automatically generated: DO NOT MODIFY. */" );
 320     ListHeaderFiles();
 321     BlankLine();
 322     ListExternalFunctions();
 323     BlankLine();
 324     EmitUnitTesterBody();
 325 }
 326
 327 void FileName( char *base )
 328 {
 329     strncpy( g_fileName, base, MAX_LINE_LENGTH );
 330     g_fileName[ MAX_LINE_LENGTH - 1 ] = 0;
 331 }
 332
 333 int LoadArgument( void )
 334 {
 335    if ( g_index >= g_count )
 336       return 0;
 337
 338    FileName( g_wildcards[g_index] );
 339    g_index++;  /* MUST come after FileName() call; bad code smell */
 340    return 1;
 341 }
 342
 343 void StartArguments( int starting, int count, char *array[] )
 344 {
 345    g_index = starting;
 346    g_count = count;
 347    g_wildcards = array;
 348
 349    g_ready = LoadArgument();
 350 }
 351
 352 int NextArgument( void )
 353 {
 354    if( g_ready )
 355       g_ready = LoadArgument();
 356
 357    return g_ready;
 358 }
 359
 360 char *GetArgument( void )
 361 {
 362    if( g_ready )
 363       return g_fileName;
 364
 365    return NULL;
 366 }
 367
 368 void EstablishOutputFile( int argc, char *argv[] )
 369 {
 370    int i;
 371
 372    i = 0;
 373    while( i < argc )
 374    {
 375       if( ( argv[i+1] != NULL ) && ( strcmp( argv[i], "-o" ) == 0 ) )
 376       {
 377          outfile = fopen( argv[i+1], "wb+" );
 378          if( outfile == NULL )
 379             fprintf( stderr, "ERROR: Can't open %s for writing.\n", argv[i+1] );
 380
 381          argv[i] = argv[i+1] = DO_NOT_PROCESS;
 382
 383          return;
 384       }
 385
 386       i++;
 387    }
 388
 389    outfile = stdout;
 390 }
 391
 392 int main( int argc,char *argv[] )
 393 {
 394    char *filename;
 395
 396    if ( argc < 2 )
 397    {
 398       fprintf(
 399               stderr,
 400               "USAGE:\n"
 401               "   %s [options] <input file> [<input file> [...]]\n"
 402               "\n"
 403               "OPTIONS:\n"
 404               "   -o filename   Specifies output file.\n"
 405               "\n"
 406               "NOTES:\n"
 407               "   If -o is left unspecified, output defaults to stdout.\n",
 408               argv[0]
 409              );
 410       return 3;
 411    }
 412
 413    EstablishOutputFile( argc, argv );
 414
 415    /* Skip the executable's name and the output filename. */
 416    StartArguments(0,argc,argv);
 417
 418    /* Consume the rest of the arguments, one at a time. */
 419    while ( NextArgument() )
 420    {
 421       filename = GetArgument();
 422
 423       if( strcmp( filename, DO_NOT_PROCESS ) )
 424       {
 425          fprintf( stderr, "  - parsing '%s'... ", filename);
 426          ProcessSourceFile( filename );
 427          fprintf( stderr, "done.\n");
 428       }
 429    }
 430
 431    EmitCutCheck();
 432    fflush(outfile);
 433    fclose(outfile);
 434    return 0;
 435 }
 436
 437 char * libCUT[] =
 438 {
 439    "/*",
 440    " * libcut.inc",
 441    " * CUT 2.1",
 442    " *",
 443    " * Copyright (c) 2001-2002 Samuel A. Falvo II, William D. Tanksley",
 444    " * See CUT-LICENSE.TXT for details.",
 445    " *",
 446    " * Based on WDT's 'TestAssert' package.",
 447    " *",
 448    " * $log$",
 449    " */",
 450    "",
 451    "#include <string.h>",
 452    "#include <stdlib.h>",
 453    "#include <stdio.h>",
 454    "#include <stdarg.h>",
 455    "#include \"cut.h\"",
 456    "",
 457    "#ifndef BOOL                /* Just in case -- helps in portability */",
 458    "#define BOOL int",
 459    "#endif",
 460    "",
 461    "#ifndef FALSE",
 462    "#define FALSE (0)",
 463    "#endif",
 464    "",
 465    "#ifndef TRUE",
 466    "#define TRUE 1",
 467    "#endif",
 468    "",
 469    "typedef struct NameStackItem   NameStackItem;",
 470    "typedef struct NameStackItem  *NameStack;",
 471    "",
 472    "struct NameStackItem",
 473    "{",
 474    "  NameStackItem *      next;",
 475    "  char *               name;",
 476    "  CUTTakedownFunction *takedown;",
 477    "};",
 478    "",
 479    "static int            breakpoint = 0;",
 480    "static int            count = 0;",
 481    "static BOOL           test_hit_error = FALSE;",
 482    "static NameStack      nameStack;",
 483    "",
 484    "static void traceback( void );",
 485    "static void cut_exit( void );",
 486    "",
 487    "/* I/O Functions */",
 488    "",
 489    "static void print_string( char *string )",
 490    "{",
 491    "  printf( \"%s\", string );",
 492    "  fflush( stdout );",
 493    "}",
 494    "",
 495    "static void print_string_as_error( char *filename, int lineNumber, char *string )",
 496    "{",
 497    "  printf( \"%s(%d): %s\", filename, lineNumber, string );",
 498    "  fflush( stdout );",
 499    "}",
 500    "",
 501    "static void print_integer_as_expected( int i )",
 502    "{",
 503    "  printf( \"(signed) %d (unsigned) %u (hex) 0x%08X\", i, i, i );",
 504    "}",
 505    "",
 506    "static void print_integer( int i )",
 507    "{",
 508    "  printf( \"%d\", i );",
 509    "  fflush( stdout );",
 510    "}",
 511    "",
 512    "static void print_integer_in_field( int i, int width )",
 513    "{",
 514    "  printf( \"%*d\", width, i );",
 515    "  fflush( stdout );",
 516    "}",
 517    "",
 518    "static void new_line( void )",
 519    "{",
 520    "  printf( \"\\n\" );",
 521    "  fflush( stdout );",
 522    "}",
 523    "",
 524    "static void print_character( char ch )",
 525    "{",
 526    "  printf( \"%c\", ch );",
 527    "  fflush( stdout );",
 528    "}",
 529    "",
 530    "static void dot( void )",
 531    "{",
 532    "  print_character( '.' );",
 533    "}",
 534    "",
 535    "static void space( void )",
 536    "{",
 537    "  print_character( ' ' );",
 538    "}",
 539    "",
 540    "/* Name Stack Functions */",
 541    "",
 542    "static NameStackItem *stack_topOf( NameStack *stack )",
 543    "{",
 544    "  return *stack;",
 545    "}",
 546    "",
 547    "static BOOL stack_isEmpty( NameStack *stack )",
 548    "{",
 549    "  return stack_topOf( stack ) == NULL;",
 550    "}",
 551    "",
 552    "static BOOL stack_isNotEmpty( NameStack *stack )",
 553    "{",
 554    "  return !( stack_isEmpty( stack ) );",
 555    "}",
 556    "",
 557    "static void stack_push( NameStack *stack, char *name, CUTTakedownFunction *tdfunc )",
 558    "{",
 559    "  NameStackItem *item;",
 560    "",
 561    "  item = (NameStackItem *)( malloc( sizeof( NameStackItem ) ) );",
 562    "  if( item != NULL )",
 563    "  {",
 564    "    item -> next = stack_topOf( stack );",
 565    "    item -> name = name;",
 566    "    item -> takedown = tdfunc;",
 567    "",
 568    "    *stack = item;",
 569    "  }",
 570    "}",
 571    "",
 572    "static void stack_drop( NameStack *stack )",
 573    "{",
 574    "  NameStackItem *oldItem;",
 575    "",
 576    "  if( stack_isNotEmpty( stack ) )",
 577    "  {",
 578    "    oldItem = stack_topOf( stack );",
 579    "    *stack = oldItem -> next;",
 580    "",
 581    "    free( oldItem );",
 582    "  }",
 583    "}",
 584    "",
 585    "/* CUT Initialization and Takedown  Functions */",
 586    "",
 587    "void cut_init( int brkpoint )",
 588    "{",
 589    "  breakpoint = brkpoint;",
 590    "  count = 0;",
 591    "  test_hit_error = FALSE;",
 592    "  nameStack = NULL;",
 593    "",
 594    "  if( brkpoint >= 0 )",
 595    "  {",
 596    "    print_string( \"Breakpoint at test \" );",
 597    "    print_integer( brkpoint );",
 598    "    new_line();",
 599    "  }",
 600    "}",
 601    "",
 602    "void cut_exit( void )",
 603    "{",
 604    "  exit( test_hit_error != FALSE );",
 605    "}",
 606    "",
 607    "/* User Interface functions */",
 608    "",
 609    "static void print_group( int position, int base, int leftover )",
 610    "{",
 611    "  if( !leftover )",
 612    "    return;",
 613    "",
 614    "  print_integer_in_field( base, position );",
 615    "  while( --leftover )",
 616    "    dot();",
 617    "}",
 618    "",
 619    "static void print_recap( int count )",
 620    "{",
 621    "  int countsOnLastLine = count % 50;",
 622    "  int groupsOnLastLine = countsOnLastLine / 10;",
 623    "  int dotsLeftOver = countsOnLastLine % 10;",
 624    "  int lastGroupLocation =",
 625    "     countsOnLastLine - dotsLeftOver + ( 4 * groupsOnLastLine ) + 5;",
 626    "",
 627    "  if( dotsLeftOver == 0 )",
 628    "  {",
 629    "    if( countsOnLastLine == 0 )",
 630    "      lastGroupLocation = 61;",
 631    "    else",
 632    "      lastGroupLocation -= 14;",
 633    "",
 634    "    print_group( lastGroupLocation, countsOnLastLine-10, 10);",
 635    "  }",
 636    "  else",
 637    "  {",
 638    "    print_group(",
 639    "                lastGroupLocation,",
 640    "                countsOnLastLine - dotsLeftOver,",
 641    "                dotsLeftOver",
 642    "               );",
 643    "  }",
 644    "}",
 645    "",
 646    "void cut_break_formatting( void ) // DEPRECATED: Do not use in future software",
 647    "{",
 648    "  new_line();",
 649    "}",
 650    "",
 651    "void cut_resume_formatting( void )",
 652    "{",
 653    "  new_line();",
 654    "  print_recap( count );",
 655    "}",
 656    "",
 657    "void cut_interject( const char *comment, ... )",
 658    "{",
 659    "  va_list marker;",
 660    "  va_start(marker,comment);",
 661    "  ",
 662    "  cut_break_formatting();",
 663    "  vprintf(comment,marker);",
 664    "  cut_resume_formatting();",
 665    "  ",
 666    "  va_end(marker);",
 667    "}",
 668    "",
 669    "/* Test Progress Accounting functions */",
 670    "",
 671    "void __cut_mark_point( char *filename, int lineNumber )",
 672    "{",
 673    "  if( ( count % 10 ) == 0 )",
 674    "  {",
 675    "    if( ( count % 50 ) == 0 )",
 676    "      new_line();",
 677    "",
 678    "    print_integer_in_field( count, 5 );",
 679    "  }",
 680    "  else",
 681    "    dot();",
 682    "",
 683    "  count++;",
 684    "  if( count == breakpoint )",
 685    "  {",
 686    "    print_string_as_error( filename, lineNumber, \"Breakpoint hit\" );",
 687    "    new_line();",
 688    "    traceback();",
 689    "    cut_exit();",
 690    "  }",
 691    "}",
 692    "",
 693    "void __cut_assert_equals( // DEPRECATED: Do not use in future software",
 694    "                         char *filename,",
 695    "                         int   lineNumber,",
 696    "                         char *message,",
 697    "                         char *expression,",
 698    "                         BOOL  success,",
 699    "                         int   expected",
 700    "                        )",
 701    "{",
 702    "  __cut_mark_point( filename, lineNumber );",
 703    "  ",
 704    "  if( success != FALSE )",
 705    "    return;",
 706    "  ",
 707    "  cut_break_formatting();",
 708    "  print_string_as_error( filename, lineNumber, message );",
 709    "  new_line();",
 710    "  print_string_as_error( filename, lineNumber, \"Failed expression: \" );",
 711    "  print_string( expression );",
 712    "  new_line();",
 713    "  print_string_as_error( filename, lineNumber, \"Actual value: \" );",
 714    "  print_integer_as_expected( expected );",
 715    "  new_line();",
 716    "",
 717    "  test_hit_error = TRUE;",
 718    "  cut_resume_formatting();",
 719    "}",
 720    "",
 721    "",
 722    "void __cut_assert(",
 723    "                  char *filename,",
 724    "                  int   lineNumber,",
 725    "                  char *message,",
 726    "                  char *expression,",
 727    "                  BOOL  success",
 728    "                 )",
 729    "{",
 730    "  __cut_mark_point( filename, lineNumber );",
 731    "  ",
 732    "  if( success != FALSE )",
 733    "    return;",
 734    "  ",
 735    "  cut_break_formatting();",
 736    "  print_string_as_error( filename, lineNumber, message );",
 737    "  new_line();",
 738    "  print_string_as_error( filename, lineNumber, \"Failed expression: \" );",
 739    "  print_string( expression );",
 740    "  new_line();",
 741    "",
 742    "  test_hit_error = TRUE;",
 743    "  cut_resume_formatting();",
 744    "}",
 745    "",
 746    "",
 747    "/* Test Delineation and Teardown Support Functions */",
 748    "",
 749    "static void traceback()",
 750    "{",
 751    "  if( stack_isNotEmpty( &nameStack ) )",
 752    "    print_string( \"Traceback\" );",
 753    "  else",
 754    "    print_string( \"(No traceback available.)\" );",
 755    "",
 756    "  while( stack_isNotEmpty( &nameStack ) )",
 757    "  {",
 758    "    print_string( \": \" );",
 759    "    print_string( stack_topOf( &nameStack ) -> name );",
 760    "",
 761    "    if( stack_topOf( &nameStack ) -> takedown != NULL )",
 762    "    {",
 763    "      print_string( \"(taking down)\" );",
 764    "      stack_topOf( &nameStack ) -> takedown();",
 765    "    }",
 766    "",
 767    "    stack_drop( &nameStack );",
 768    "",
 769    "    if( stack_isNotEmpty( &nameStack ) )",
 770    "      space();",
 771    "  }",
 772    "",
 773    "  new_line();",
 774    "}",
 775    "",
 776    "void cut_start( char *name, CUTTakedownFunction *takedownFunction )",
 777    "{",
 778    "  stack_push( &nameStack, name, takedownFunction );",
 779    "}",
 780    "",
 781    "int __cut_check_errors( char *filename, int lineNumber )",
 782    "{",
 783    "  if( test_hit_error || stack_isEmpty( &nameStack ) )",
 784    "  {",
 785    "    cut_break_formatting();",
 786    "    if( stack_isEmpty( &nameStack ) )",
 787    "      print_string_as_error( filename, lineNumber, \"Missing cut_start(); no traceback possible.\" );",
 788    "    else",
 789    "      traceback();",
 790    "",
 791    "    cut_exit();",
 792    "    return 0;",
 793    "  } else return 1;",
 794    "}",
 795    "",
 796    "void __cut_end( char *filename, int lineNumber, char *closingFrame )",
 797    "{",
 798    "  if( test_hit_error || stack_isEmpty( &nameStack ) )",
 799    "  {",
 800    "    cut_break_formatting();",
 801    "    if( stack_isEmpty( &nameStack ) )",
 802    "      print_string_as_error( filename, lineNumber, \"Missing cut_start(); no traceback possible.\" );",
 803    "    else",
 804    "      traceback();",
 805    "",
 806    "    cut_exit();",
 807    "  }",
 808    "  else",
 809    "  {",
 810    "    if( strcmp( stack_topOf( &nameStack ) -> name, closingFrame ) == 0 )",
 811    "      stack_drop( &nameStack );",
 812    "    else",
 813    "    {",
 814    "      print_string_as_error( filename, lineNumber, \"Mismatched cut_end().\" );",
 815    "      traceback();",
 816    "      cut_exit();",
 817    "    }",
 818    "  }",
 819    "}",
 820    0
 821 };
 822
 823 /*
 824  * vim: tabstop=3 shiftwidth=3 expandtab
 825  */
 826