tagmanager/get.c

   1 /*
   2 *   Copyright (c) 1996-2002, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License.
   6 *
   7 *   This module contains the high level source read functions (preprocessor
   8 *   directives are handled within this level).
   9 */
  10
  11 /*
  12 *   INCLUDE FILES
  13 */
  14 #include "general.h"  /* must always come first */
  15
  16 #include <string.h>
  17 #include <glib.h>
  18
  19 #include "entry.h"
  20 #include "get.h"
  21 #include "options.h"
  22 #include "read.h"
  23 #include "vstring.h"
  24
  25 /*
  26 *   MACROS
  27 */
  28 #define stringMatch(s1,s2)              (strcmp (s1,s2) == 0)
  29 #define isspacetab(c)                   ((c) == SPACE || (c) == TAB)
  30
  31 /*
  32 *   DATA DECLARATIONS
  33 */
  34 typedef enum { COMMENT_NONE, COMMENT_C, COMMENT_CPLUS, COMMENT_D } Comment;
  35
  36 enum eCppLimits {
  37         MaxCppNestingLevel = 20,
  38         MaxDirectiveName = 10
  39 };
  40
  41 /*  Defines the one nesting level of a preprocessor conditional.
  42  */
  43 typedef struct sConditionalInfo {
  44         boolean ignoreAllBranches;  /* ignoring parent conditional branch */
  45         boolean singleBranch;       /* choose only one branch */
  46         boolean branchChosen;       /* branch already selected */
  47         boolean ignoring;           /* current ignore state */
  48 } conditionalInfo;
  49
  50 enum eState {
  51         DRCTV_NONE,    /* no known directive - ignore to end of line */
  52         DRCTV_DEFINE,  /* "#define" encountered */
  53         DRCTV_HASH,    /* initial '#' read; determine directive */
  54         DRCTV_IF,      /* "#if" or "#ifdef" encountered */
  55         DRCTV_PRAGMA,  /* #pragma encountered */
  56         DRCTV_UNDEF    /* "#undef" encountered */
  57 };
  58
  59 /*  Defines the current state of the pre-processor.
  60  */
  61 typedef struct sCppState {
  62         int             ungetch, ungetch2;   /* ungotten characters, if any */
  63         boolean resolveRequired;     /* must resolve if/else/elif/endif branch */
  64         boolean hasAtLiteralStrings; /* supports @"c:\" strings */
  65         struct sDirective {
  66                 enum eState state;       /* current directive being processed */
  67                 boolean accept;          /* is a directive syntactically permitted? */
  68                 vString * name;          /* macro name */
  69                 unsigned int nestLevel;  /* level 0 is not used */
  70                 conditionalInfo ifdef [MaxCppNestingLevel];
  71         } directive;
  72 } cppState;
  73
  74 /*
  75 *   DATA DEFINITIONS
  76 */
  77
  78 /*  Use brace formatting to detect end of block.
  79  */
  80 static boolean BraceFormat = FALSE;
  81
  82 static cppState Cpp = {
  83         '\0', '\0',  /* ungetch characters */
  84         FALSE,       /* resolveRequired */
  85         FALSE,       /* hasAtLiteralStrings */
  86         {
  87                 DRCTV_NONE,  /* state */
  88                 FALSE,       /* accept */
  89                 NULL,        /* tag name */
  90                 0,           /* nestLevel */
  91                 { {FALSE,FALSE,FALSE,FALSE} }  /* ifdef array */
  92         }  /* directive */
  93 };
  94
  95 /*
  96 *   FUNCTION DEFINITIONS
  97 */
  98
  99 extern boolean isBraceFormat (void)
 100 {
 101         return BraceFormat;
 102 }
 103
 104 extern unsigned int getDirectiveNestLevel (void)
 105 {
 106         return Cpp.directive.nestLevel;
 107 }
 108
 109 extern void cppInit (const boolean state, const boolean hasAtLiteralStrings)
 110 {
 111         BraceFormat = state;
 112
 113         Cpp.ungetch         = '\0';
 114         Cpp.ungetch2        = '\0';
 115         Cpp.resolveRequired = FALSE;
 116         Cpp.hasAtLiteralStrings = hasAtLiteralStrings;
 117
 118         Cpp.directive.state     = DRCTV_NONE;
 119         Cpp.directive.accept    = TRUE;
 120         Cpp.directive.nestLevel = 0;
 121
 122         Cpp.directive.ifdef [0].ignoreAllBranches = FALSE;
 123         Cpp.directive.ifdef [0].singleBranch = FALSE;
 124         Cpp.directive.ifdef [0].branchChosen = FALSE;
 125         Cpp.directive.ifdef [0].ignoring     = FALSE;
 126
 127         if (Cpp.directive.name == NULL)
 128                 Cpp.directive.name = vStringNew ();
 129         else
 130                 vStringClear (Cpp.directive.name);
 131 }
 132
 133 extern void cppTerminate (void)
 134 {
 135         if (Cpp.directive.name != NULL)
 136         {
 137                 vStringDelete (Cpp.directive.name);
 138                 Cpp.directive.name = NULL;
 139         }
 140 }
 141
 142 extern void cppBeginStatement (void)
 143 {
 144         Cpp.resolveRequired = TRUE;
 145 }
 146
 147 extern void cppEndStatement (void)
 148 {
 149         Cpp.resolveRequired = FALSE;
 150 }
 151
 152 /*
 153 *   Scanning functions
 154 *
 155 *   This section handles preprocessor directives.  It strips out all
 156 *   directives and may emit a tag for #define directives.
 157 */
 158
 159 /*  This puts a character back into the input queue for the source File.
 160  *  Up to two characters may be ungotten.
 161  */
 162 extern void cppUngetc (const int c)
 163 {
 164         Assert (Cpp.ungetch2 == '\0');
 165         Cpp.ungetch2 = Cpp.ungetch;
 166         Cpp.ungetch = c;
 167 }
 168
 169 /*  Reads a directive, whose first character is given by "c", into "name".
 170  */
 171 static boolean readDirective (int c, char *const name, unsigned int maxLength)
 172 {
 173         unsigned int i;
 174
 175         for (i = 0  ;  i < maxLength - 1  ;  ++i)
 176         {
 177                 if (i > 0)
 178                 {
 179                         c = fileGetc ();
 180                         if (c == EOF  ||  ! isalpha (c))
 181                         {
 182                                 fileUngetc (c);
 183                                 break;
 184                         }
 185                 }
 186                 name [i] = c;
 187         }
 188         name [i] = '\0';  /* null terminate */
 189
 190         return (boolean) isspacetab (c);
 191 }
 192
 193 /*  Reads an identifier, whose first character is given by "c", into "tag",
 194  *  together with the file location and corresponding line number.
 195  */
 196 static void readIdentifier (int c, vString *const name)
 197 {
 198         vStringClear (name);
 199         do
 200         {
 201                 vStringPut (name, c);
 202         } while (c = fileGetc (), (c != EOF  &&  isident (c)));
 203         fileUngetc (c);
 204         vStringTerminate (name);
 205 }
 206
 207 static conditionalInfo *currentConditional (void)
 208 {
 209         return &Cpp.directive.ifdef [Cpp.directive.nestLevel];
 210 }
 211
 212 static boolean isIgnore (void)
 213 {
 214         return Cpp.directive.ifdef [Cpp.directive.nestLevel].ignoring;
 215 }
 216
 217 static boolean setIgnore (const boolean ignore)
 218 {
 219         return Cpp.directive.ifdef [Cpp.directive.nestLevel].ignoring = ignore;
 220 }
 221
 222 static boolean isIgnoreBranch (void)
 223 {
 224         conditionalInfo *const ifdef = currentConditional ();
 225
 226         /*  Force a single branch if an incomplete statement is discovered
 227          *  en route. This may have allowed earlier branches containing complete
 228          *  statements to be followed, but we must follow no further branches.
 229          */
 230         if (Cpp.resolveRequired  &&  ! BraceFormat)
 231                 ifdef->singleBranch = TRUE;
 232
 233         /*  We will ignore this branch in the following cases:
 234          *
 235          *  1.  We are ignoring all branches (conditional was within an ignored
 236          *        branch of the parent conditional)
 237          *  2.  A branch has already been chosen and either of:
 238          *      a.  A statement was incomplete upon entering the conditional
 239          *      b.  A statement is incomplete upon encountering a branch
 240          */
 241         return (boolean) (ifdef->ignoreAllBranches ||
 242                                          (ifdef->branchChosen  &&  ifdef->singleBranch));
 243 }
 244
 245 static void chooseBranch (void)
 246 {
 247         if (! BraceFormat)
 248         {
 249                 conditionalInfo *const ifdef = currentConditional ();
 250
 251                 ifdef->branchChosen = (boolean) (ifdef->singleBranch ||
 252                                                                                 Cpp.resolveRequired);
 253         }
 254 }
 255
 256 /*  Pushes one nesting level for an #if directive, indicating whether or not
 257  *  the branch should be ignored and whether a branch has already been chosen.
 258  */
 259 static boolean pushConditional (const boolean firstBranchChosen)
 260 {
 261         const boolean ignoreAllBranches = isIgnore ();  /* current ignore */
 262         boolean ignoreBranch = FALSE;
 263
 264         if (Cpp.directive.nestLevel < (unsigned int) MaxCppNestingLevel - 1)
 265         {
 266                 conditionalInfo *ifdef;
 267
 268                 ++Cpp.directive.nestLevel;
 269                 ifdef = currentConditional ();
 270
 271                 /*  We take a snapshot of whether there is an incomplete statement in
 272                  *  progress upon encountering the preprocessor conditional. If so,
 273                  *  then we will flag that only a single branch of the conditional
 274                  *  should be followed.
 275                  */
 276                 ifdef->ignoreAllBranches = ignoreAllBranches;
 277                 ifdef->singleBranch      = Cpp.resolveRequired;
 278                 ifdef->branchChosen      = firstBranchChosen;
 279                 ifdef->ignoring = (boolean) (ignoreAllBranches || (
 280                                 ! firstBranchChosen  &&  ! BraceFormat  &&
 281                                 (ifdef->singleBranch || !Option.if0)));
 282                 ignoreBranch = ifdef->ignoring;
 283         }
 284         return ignoreBranch;
 285 }
 286
 287 /*  Pops one nesting level for an #endif directive.
 288  */
 289 static boolean popConditional (void)
 290 {
 291         if (Cpp.directive.nestLevel > 0)
 292                 --Cpp.directive.nestLevel;
 293
 294         return isIgnore ();
 295 }
 296
 297 static void makeDefineTag (const char *const name, boolean parameterized)
 298 {
 299         const boolean isFileScope = (boolean) (! isHeaderFile ());
 300
 301         if (includingDefineTags () &&
 302                 (! isFileScope  ||  Option.include.fileScope))
 303         {
 304                 tagEntryInfo e;
 305
 306                 initTagEntry (&e, name);
 307
 308                 e.lineNumberEntry = (boolean) (Option.locate != EX_PATTERN);
 309                 e.isFileScope  = isFileScope;
 310                 e.truncateLine = TRUE;
 311                 e.kindName     = "macro";
 312                 e.kind         = 'd';
 313                 if (parameterized)
 314                 {
 315                         e.extensionFields.arglist = getArglistFromFilePos(getInputFilePosition()
 316                                         , e.name);
 317                 }
 318                 makeTagEntry (&e);
 319                 if (parameterized)
 320                         free((char *) e.extensionFields.arglist);
 321         }
 322 }
 323
 324 static void directiveDefine (const int c)
 325 {
 326         boolean parameterized;
 327         int nc;
 328
 329         if (isident1 (c))
 330         {
 331                 readIdentifier (c, Cpp.directive.name);
 332                 nc = fileGetc ();
 333                 fileUngetc (nc);
 334                 parameterized = (boolean) (nc == '(');
 335                 if (! isIgnore ())
 336                         makeDefineTag (vStringValue (Cpp.directive.name), parameterized);
 337         }
 338         Cpp.directive.state = DRCTV_NONE;
 339 }
 340
 341 static void directivePragma (int c)
 342 {
 343         if (isident1 (c))
 344         {
 345                 readIdentifier (c, Cpp.directive.name);
 346                 if (stringMatch (vStringValue (Cpp.directive.name), "weak"))
 347                 {
 348                         /* generate macro tag for weak name */
 349                         do
 350                         {
 351                                 c = fileGetc ();
 352                         } while (c == SPACE);
 353                         if (isident1 (c))
 354                         {
 355                                 readIdentifier (c, Cpp.directive.name);
 356                                 makeDefineTag (vStringValue (Cpp.directive.name), FALSE);
 357                         }
 358                 }
 359         }
 360         Cpp.directive.state = DRCTV_NONE;
 361 }
 362
 363 static boolean directiveIf (const int c)
 364 {
 365         const boolean ignore = pushConditional ((boolean) (c != '0'));
 366
 367         Cpp.directive.state = DRCTV_NONE;
 368
 369         return ignore;
 370 }
 371
 372 static boolean directiveHash (const int c)
 373 {
 374         boolean ignore = FALSE;
 375         char directive [MaxDirectiveName];
 376         DebugStatement ( const boolean ignore0 = isIgnore (); )
 377
 378         readDirective (c, directive, MaxDirectiveName);
 379         if (stringMatch (directive, "define"))
 380                 Cpp.directive.state = DRCTV_DEFINE;
 381         else if (stringMatch (directive, "undef"))
 382                 Cpp.directive.state = DRCTV_UNDEF;
 383         else if (strncmp (directive, "if", (size_t) 2) == 0)
 384                 Cpp.directive.state = DRCTV_IF;
 385         else if (stringMatch (directive, "elif")  ||
 386                         stringMatch (directive, "else"))
 387         {
 388                 ignore = setIgnore (isIgnoreBranch ());
 389                 if (! ignore  &&  stringMatch (directive, "else"))
 390                         chooseBranch ();
 391                 Cpp.directive.state = DRCTV_NONE;
 392                 DebugStatement ( if (ignore != ignore0) debugCppIgnore (ignore); )
 393         }
 394         else if (stringMatch (directive, "endif"))
 395         {
 396                 DebugStatement ( debugCppNest (FALSE, Cpp.directive.nestLevel); )
 397                 ignore = popConditional ();
 398                 Cpp.directive.state = DRCTV_NONE;
 399                 DebugStatement ( if (ignore != ignore0) debugCppIgnore (ignore); )
 400         }
 401         else if (stringMatch (directive, "pragma"))
 402                 Cpp.directive.state = DRCTV_PRAGMA;
 403         else
 404                 Cpp.directive.state = DRCTV_NONE;
 405
 406         return ignore;
 407 }
 408
 409 /*  Handles a pre-processor directive whose first character is given by "c".
 410  */
 411 static boolean handleDirective (const int c)
 412 {
 413         boolean ignore = isIgnore ();
 414
 415         switch (Cpp.directive.state)
 416         {
 417                 case DRCTV_NONE:    ignore = isIgnore ();        break;
 418                 case DRCTV_DEFINE:  directiveDefine (c);         break;
 419                 case DRCTV_HASH:    ignore = directiveHash (c);  break;
 420                 case DRCTV_IF:      ignore = directiveIf (c);    break;
 421                 case DRCTV_PRAGMA:  directivePragma (c);         break;
 422                 case DRCTV_UNDEF:   directiveDefine (c);         break;
 423         }
 424         return ignore;
 425 }
 426
 427 /*  Called upon reading of a slash ('/') characters, determines whether a
 428  *  comment is encountered, and its type.
 429  */
 430 static Comment isComment (void)
 431 {
 432         Comment comment;
 433         const int next = fileGetc ();
 434
 435         if (next == '*')
 436                 comment = COMMENT_C;
 437         else if (next == '/')
 438                 comment = COMMENT_CPLUS;
 439         else if (next == '+')
 440                 comment = COMMENT_D;
 441         else
 442         {
 443                 fileUngetc (next);
 444                 comment = COMMENT_NONE;
 445         }
 446         return comment;
 447 }
 448
 449 /*  Skips over a C style comment. According to ANSI specification a comment
 450  *  is treated as white space, so we perform this substitution.
 451  */
 452 int skipOverCComment (void)
 453 {
 454         int c = fileGetc ();
 455
 456         while (c != EOF)
 457         {
 458                 if (c != '*')
 459                         c = fileGetc ();
 460                 else
 461                 {
 462                         const int next = fileGetc ();
 463
 464                         if (next != '/')
 465                                 c = next;
 466                         else
 467                         {
 468                                 c = SPACE;  /* replace comment with space */
 469                                 break;
 470                         }
 471                 }
 472         }
 473         return c;
 474 }
 475
 476 /*  Skips over a C++ style comment.
 477  */
 478 static int skipOverCplusComment (void)
 479 {
 480         int c;
 481
 482         while ((c = fileGetc ()) != EOF)
 483         {
 484                 if (c == BACKSLASH)
 485                         fileGetc ();  /* throw away next character, too */
 486                 else if (c == NEWLINE)
 487                         break;
 488         }
 489         return c;
 490 }
 491
 492 /* Skips over a D style comment.
 493  * Really we should match nested /+ comments. At least they're less common.
 494  */
 495 static int skipOverDComment (void)
 496 {
 497         int c = fileGetc ();
 498
 499         while (c != EOF)
 500         {
 501                 if (c != '+')
 502                         c = fileGetc ();
 503                 else
 504                 {
 505                         const int next = fileGetc ();
 506
 507                         if (next != '/')
 508                                 c = next;
 509                         else
 510                         {
 511                                 c = SPACE;  /* replace comment with space */
 512                                 break;
 513                         }
 514                 }
 515         }
 516         return c;
 517 }
 518
 519 /*  Skips to the end of a string, returning a special character to
 520  *  symbolically represent a generic string.
 521  */
 522 static int skipToEndOfString (boolean ignoreBackslash)
 523 {
 524         int c;
 525
 526         while ((c = fileGetc ()) != EOF)
 527         {
 528                 if (c == BACKSLASH && ! ignoreBackslash)
 529                         fileGetc ();  /* throw away next character, too */
 530                 else if (c == DOUBLE_QUOTE)
 531                         break;
 532         }
 533         return STRING_SYMBOL;  /* symbolic representation of string */
 534 }
 535
 536 /*  Skips to the end of the three (possibly four) 'c' sequence, returning a
 537  *  special character to symbolically represent a generic character.
 538  *  Also detects Vera numbers that include a base specifier (ie. 'b1010).
 539  */
 540 static int skipToEndOfChar (void)
 541 {
 542         int c;
 543         int count = 0, veraBase = '\0';
 544
 545         while ((c = fileGetc ()) != EOF)
 546         {
 547             ++count;
 548                 if (c == BACKSLASH)
 549                         fileGetc ();  /* throw away next character, too */
 550                 else if (c == SINGLE_QUOTE)
 551                         break;
 552                 else if (c == NEWLINE)
 553                 {
 554                         fileUngetc (c);
 555                         break;
 556                 }
 557                 else if (count == 1  &&  strchr ("DHOB", toupper (c)) != NULL)
 558                         veraBase = c;
 559                 else if (veraBase != '\0'  &&  ! isalnum (c))
 560                 {
 561                         fileUngetc (c);
 562                         break;
 563                 }
 564         }
 565         return CHAR_SYMBOL;  /* symbolic representation of character */
 566 }
 567
 568 /*  This function returns the next character, stripping out comments,
 569  *  C pre-processor directives, and the contents of single and double
 570  *  quoted strings. In short, strip anything which places a burden upon
 571  *  the tokenizer.
 572  */
 573 extern int cppGetc (void)
 574 {
 575         boolean directive = FALSE;
 576         boolean ignore = FALSE;
 577         int c;
 578
 579         if (Cpp.ungetch != '\0')
 580         {
 581                 c = Cpp.ungetch;
 582                 Cpp.ungetch = Cpp.ungetch2;
 583                 Cpp.ungetch2 = '\0';
 584                 return c;  /* return here to avoid re-calling debugPutc () */
 585         }
 586         else do
 587         {
 588                 c = fileGetc ();
 589 process:
 590                 switch (c)
 591                 {
 592                         case EOF:
 593                                 ignore    = FALSE;
 594                                 directive = FALSE;
 595                                 break;
 596
 597                         case TAB:
 598                         case SPACE:
 599                                 break;  /* ignore most white space */
 600
 601                         case NEWLINE:
 602                                 if (directive  &&  ! ignore)
 603                                         directive = FALSE;
 604                                 Cpp.directive.accept = TRUE;
 605                                 break;
 606
 607                         case DOUBLE_QUOTE:
 608                                 Cpp.directive.accept = FALSE;
 609                                 c = skipToEndOfString (FALSE);
 610                                 break;
 611
 612                         case '#':
 613                                 if (Cpp.directive.accept)
 614                                 {
 615                                         directive = TRUE;
 616                                         Cpp.directive.state  = DRCTV_HASH;
 617                                         Cpp.directive.accept = FALSE;
 618                                 }
 619                                 break;
 620
 621                         case SINGLE_QUOTE:
 622                                 Cpp.directive.accept = FALSE;
 623                                 c = skipToEndOfChar ();
 624                                 break;
 625
 626                         case '/':
 627                         {
 628                                 const Comment comment = isComment ();
 629
 630                                 if (comment == COMMENT_C)
 631                                         c = skipOverCComment ();
 632                                 else if (comment == COMMENT_CPLUS)
 633                                 {
 634                                         c = skipOverCplusComment ();
 635                                         if (c == NEWLINE)
 636                                                 fileUngetc (c);
 637                                 }
 638                                 else if (comment == COMMENT_D)
 639                                         c = skipOverDComment ();
 640                                 else
 641                                         Cpp.directive.accept = FALSE;
 642                                 break;
 643                         }
 644
 645                         case BACKSLASH:
 646                         {
 647                                 int next = fileGetc ();
 648
 649                                 if (next == NEWLINE)
 650                                         continue;
 651                                 else if (next == '?')
 652                                         cppUngetc (next);
 653                                 else
 654                                         fileUngetc (next);
 655                                 break;
 656                         }
 657
 658                         case '?':
 659                         {
 660                                 int next = fileGetc ();
 661                                 if (next != '?')
 662                                         fileUngetc (next);
 663                                 else
 664                                 {
 665                                         next = fileGetc ();
 666                                         switch (next)
 667                                         {
 668                                                 case '(':          c = '[';       break;
 669                                                 case ')':          c = ']';       break;
 670                                                 case '<':          c = '{';       break;
 671                                                 case '>':          c = '}';       break;
 672                                                 case '/':          c = BACKSLASH; goto process;
 673                                                 case '!':          c = '|';       break;
 674                                                 case SINGLE_QUOTE: c = '^';       break;
 675                                                 case '-':          c = '~';       break;
 676                                                 case '=':          c = '#';       goto process;
 677                                                 default:
 678                                                         fileUngetc (next);
 679                                                         cppUngetc ('?');
 680                                                         break;
 681                                         }
 682                                 }
 683                         } break;
 684
 685                         default:
 686                                 if (c == '@' && Cpp.hasAtLiteralStrings)
 687                                 {
 688                                         int next = fileGetc ();
 689                                         if (next == DOUBLE_QUOTE)
 690                                         {
 691                                                 Cpp.directive.accept = FALSE;
 692                                                 c = skipToEndOfString (TRUE);
 693                                                 break;
 694                                         }
 695                                 }
 696                                 Cpp.directive.accept = FALSE;
 697                                 if (directive)
 698                                         ignore = handleDirective (c);
 699                                 break;
 700                 }
 701         } while (directive || ignore);
 702
 703         DebugStatement ( debugPutc (DEBUG_CPP, c); )
 704         DebugStatement ( if (c == NEWLINE)
 705                                 debugPrintf (DEBUG_CPP, "%6ld: ", getInputLineNumber () + 1); )
 706
 707         return c;
 708 }
 709
 710 extern char *getArglistFromFilePos(MIOPos startPosition, const char *tokenName)
 711 {
 712         MIOPos originalPosition;
 713         char *result = NULL;
 714         char *arglist = NULL;
 715         long pos1, pos2;
 716
 717         pos2 = mio_tell(File.mio);
 718
 719         mio_getpos(File.mio, &originalPosition);
 720         mio_setpos(File.mio, &startPosition);
 721         pos1 = mio_tell(File.mio);
 722
 723         if (pos2 > pos1)
 724         {
 725                 result = (char *) g_malloc(sizeof(char ) * (pos2 - pos1 + 2));
 726                 if (result != NULL && mio_read(File.mio, result, sizeof(char), pos2 - pos1 + 1) > 0)
 727                 {
 728                         result[pos2-pos1+1] = '\0';
 729                         arglist = getArglistFromStr(result, tokenName);
 730                 }
 731                 g_free(result);
 732         }
 733         mio_setpos(File.mio, &originalPosition);
 734         return arglist;
 735 }
 736
 737 typedef enum
 738 {
 739         st_none_t,
 740         st_escape_t,
 741         st_c_comment_t,
 742         st_cpp_comment_t,
 743         st_double_quote_t,
 744         st_single_quote_t
 745 } ParseState;
 746
 747 static void stripCodeBuffer(char *buf)
 748 {
 749         int i = 0, pos = 0;
 750         ParseState state = st_none_t, prev_state = st_none_t;
 751
 752         while (buf[i] != '\0')
 753         {
 754                 switch(buf[i])
 755                 {
 756                         case '/':
 757                                 if (st_none_t == state)
 758                                 {
 759                                         /* Check if this is the start of a comment */
 760                                         if (buf[i+1] == '*') /* C comment */
 761                                                 state = st_c_comment_t;
 762                                         else if (buf[i+1] == '/') /* C++ comment */
 763                                                 state = st_cpp_comment_t;
 764                                         else /* Normal character */
 765                                                 buf[pos++] = '/';
 766                                 }
 767                                 else if (st_c_comment_t == state)
 768                                 {
 769                                         /* Check if this is the end of a C comment */
 770                                         if (buf[i-1] == '*')
 771                                         {
 772                                                 if ((pos > 0) && (buf[pos-1] != ' '))
 773                                                         buf[pos++] = ' ';
 774                                                 state = st_none_t;
 775                                         }
 776                                 }
 777                                 break;
 778                         case '"':
 779                                 if (st_none_t == state)
 780                                         state = st_double_quote_t;
 781                                 else if (st_double_quote_t == state)
 782                                         state = st_none_t;
 783                                 break;
 784                         case '\'':
 785                                 if (st_none_t == state)
 786                                         state = st_single_quote_t;
 787                                 else if (st_single_quote_t == state)
 788                                         state = st_none_t;
 789                                 break;
 790                         default:
 791                                 if ((buf[i] == '\\') && (st_escape_t != state))
 792                                 {
 793                                         prev_state = state;
 794                                         state = st_escape_t;
 795                                 }
 796                                 else if (st_escape_t == state)
 797                                 {
 798                                         state = prev_state;
 799                                         prev_state = st_none_t;
 800                                 }
 801                                 else if ((buf[i] == '\n') && (st_cpp_comment_t == state))
 802                                 {
 803                                         if ((pos > 0) && (buf[pos-1] != ' '))
 804                                                 buf[pos++] = ' ';
 805                                         state = st_none_t;
 806                                 }
 807                                 else if (st_none_t == state)
 808                                 {
 809                                         if (isspace(buf[i]))
 810                                         {
 811                                                 if ((pos > 0) && (buf[pos-1] != ' '))
 812                                                         buf[pos++] = ' ';
 813                                         }
 814                                         else
 815                                                 buf[pos++] = buf[i];
 816                                 }
 817                                 break;
 818                 }
 819                 ++i;
 820         }
 821         buf[pos] = '\0';
 822         return;
 823 }
 824
 825 extern char *getArglistFromStr(char *buf, const char *name)
 826 {
 827         char *start, *end;
 828         int level;
 829         if ((NULL == buf) || (NULL == name) || ('\0' == name[0]))
 830                 return NULL;
 831         stripCodeBuffer(buf);
 832         if (NULL == (start = strstr(buf, name)))
 833                 return NULL;
 834         if (NULL == (start = strchr(start, '(')))
 835                 return NULL;
 836         for (level = 1, end = start + 1; level > 0; ++end)
 837         {
 838                 if ('\0' == *end)
 839                         break;
 840                 else if ('(' == *end)
 841                         ++ level;
 842                 else if (')' == *end)
 843                         -- level;
 844         }
 845         *end = '\0';
 846         return strdup(start);
 847 }
 848
 849 /* vi:set tabstop=4 shiftwidth=4: */