config/mantomak.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <ctype.h>
  42
  43 #define DEFAULT_MANIFEST_EXT ".mn"
  44 #define DEFAULT_MAKEFILE_EXT ".win"
  45
  46 typedef struct char_list_struct {
  47     char *m_pString;
  48     struct char_list_struct *m_pNext;
  49 } char_list;
  50
  51 typedef struct macro_list_struct   {
  52     char *m_pMacro;
  53     char_list *m_pValue;
  54     struct macro_list_struct *m_pNext;
  55 } macro_list;
  56
  57 void help(void);
  58 char *input_filename(const char *);
  59 char *output_filename(const char *, const char *);
  60 int input_to_output(FILE *, FILE *);
  61 int output_rules(FILE *);
  62 int output_end(FILE *);
  63 int buffer_to_output(char *, FILE *);
  64 macro_list *extract_macros(char *);
  65 char *find_macro(char *, char **);
  66 void add_macro(char *, macro_list **);
  67 int macro_length(char *);
  68 int value_length(char *);
  69 void add_values(char *, char_list **);
  70 char *skip_white(char *);
  71 int write_macros(macro_list *, FILE *);
  72 int write_values(char_list *, FILE *, int);
  73 void free_macro_list(macro_list *);
  74 void free_char_list(char_list *);
  75 void morph_macro(macro_list **, char *, char *, char *);
  76 void slash_convert(macro_list *, char *);
  77 int explicit_rules(macro_list *, char *, FILE *);
  78 void create_classroot(macro_list **ppList );
  79
  80 int main(int argc, char *argv[])
  81 {
  82         int iOS = 0;
  83         char *pInputFile = NULL;
  84         char *pOutputFile = NULL;
  85
  86         /*      Figure out arguments.
  87          *      [REQUIRED] First argument is input file.
  88          *      [OPTIONAL] Second argument is output file.
  89          */
  90         if(argc > 1)    {
  91                 FILE *pInputStream = NULL;
  92                 FILE *pOutputStream = NULL;
  93
  94                 /*      Form respective filenames.
  95                  */
  96                 pInputFile = input_filename(argv[1]);
  97                 pOutputFile = output_filename(pInputFile, argc > 2 ? argv[2] : NULL);
  98
  99                 if(pInputFile == NULL)  {
 100                         fprintf(stderr, "MANTOMAK:  Unable to form input filename\n");
 101                         iOS = 1;
 102                 }
 103                 else    {
 104                         pInputStream = fopen(pInputFile, "rb");
 105                         if(pInputStream == NULL)        {
 106                                 fprintf(stderr, "MANTOMAK:  Unable to open input file %s\n", pInputFile);
 107                                 iOS = 1;
 108                         }
 109                 }
 110                 if(pOutputFile == NULL) {
 111                         fprintf(stderr, "MANTOMAK:  Unable to form output filename\n");
 112                         iOS = 1;
 113                 }
 114                 else if(pInputStream != NULL)   {
 115                         pOutputStream = fopen(pOutputFile, "wt");
 116                         if(pOutputStream == NULL)       {
 117                                 fprintf(stderr, "MANTOMAK:  Unable to open output file %s\n", pOutputFile);
 118                                 iOS = 1;
 119                         }
 120                 }
 121
 122                 /*      Only do the real processing if our error code is not
 123                  *              already set.
 124                  */
 125                 if(iOS == 0)    {
 126                         iOS = input_to_output(pInputStream, pOutputStream);
 127                 }
 128
 129                 if(pInputStream != NULL)        {
 130                         fclose(pInputStream);
 131                         pInputStream = NULL;
 132                 }
 133                 if(pOutputStream != NULL)       {
 134                         fclose(pOutputStream);
 135                         pOutputStream = NULL;
 136                 }
 137         }
 138         else    {
 139                 help();
 140                 iOS = 1;
 141         }
 142
 143         if(pInputFile)  {
 144                 free(pInputFile);
 145                 pInputFile = NULL;
 146         }
 147         if(pOutputFile) {
 148                 free(pOutputFile);
 149                 pOutputFile = NULL;
 150         }
 151
 152         return(iOS);
 153 }
 154
 155 void help(void)
 156 {
 157         fprintf(stderr, "USAGE:\tmantomak.exe InputFile [OutputFile]\n\n");
 158         fprintf(stderr, "InputFile:\tManifest file.  If without extension, \"%s\" assumed.\n", DEFAULT_MANIFEST_EXT);
 159         fprintf(stderr, "OutputFile:\tNMake file.  If not present, \"InputFile%s\" assumed.\n", DEFAULT_MAKEFILE_EXT);
 160 }
 161
 162 char *input_filename(const char *pInputFile)
 163 {
 164         char aResult[_MAX_PATH];
 165         char aDrive[_MAX_DRIVE];
 166         char aDir[_MAX_DIR];
 167         char aName[_MAX_FNAME];
 168         char aExt[_MAX_EXT];
 169
 170         if(pInputFile == NULL)  {
 171                 return(NULL);
 172         }
 173
 174         _splitpath(pInputFile, aDrive, aDir, aName, aExt);
 175
 176         if(aExt[0] == '\0')     {
 177                 /*      No extension provided.
 178                  *      Use the default.
 179                  */
 180                 strcpy(aExt, DEFAULT_MANIFEST_EXT);
 181         }
 182
 183         aResult[0] = '\0';
 184         _makepath(aResult, aDrive, aDir, aName, aExt);
 185
 186         if(aResult[0] == '\0')  {
 187                 return(NULL);
 188         }
 189         else    {
 190                 return(strdup(aResult));
 191         }
 192 }
 193
 194 char *output_filename(const char *pInputFile, const char *pOutputFile)
 195 {
 196         char aResult[_MAX_PATH];
 197         char aDrive[_MAX_DRIVE];
 198         char aDir[_MAX_DIR];
 199         char aName[_MAX_FNAME];
 200         char aExt[_MAX_EXT];
 201
 202         if(pOutputFile != NULL) {
 203                 return(strdup(pOutputFile));
 204         }
 205
 206         /*      From here on out, we have to create our own filename,
 207          *              implied from the input file name.
 208          */
 209
 210         if(pInputFile == NULL)  {
 211                 return(NULL);
 212         }
 213
 214         _splitpath(pInputFile, aDrive, aDir, aName, aExt);
 215         strcpy(aExt, DEFAULT_MAKEFILE_EXT);
 216
 217         aResult[0] = '\0';
 218         _makepath(aResult, aDrive, aDir, aName, aExt);
 219
 220         if(aResult[0] == '\0')  {
 221                 return(NULL);
 222         }
 223         else    {
 224                 return(strdup(aResult));
 225         }
 226 }
 227
 228 int input_to_output(FILE *pInput, FILE *pOutput)
 229 {
 230         char *pHog = NULL;
 231         long lSize = 0;
 232         int iRetval = 0;
 233
 234         /*      Read the entire file into memory.
 235          */
 236         fseek(pInput, 0, SEEK_END);
 237         lSize = ftell(pInput);
 238         fseek(pInput, 0, SEEK_SET);
 239
 240         pHog = (char *)malloc(lSize + 1);
 241         if(pHog)        {
 242                 *(pHog + lSize) = '\0';
 243                 fread(pHog, lSize, 1, pInput);
 244
 245                 iRetval = buffer_to_output(pHog, pOutput);
 246
 247                 free(pHog);
 248                 pHog = NULL;
 249         }
 250         else    {
 251                 fprintf(stderr, "MANTOMAK:  Out of Memory....\n");
 252                 iRetval = 1;
 253         }
 254
 255         return(iRetval);
 256 }
 257
 258 int output_rules(FILE *pOutput)
 259 {
 260         int iRetval = 0;
 261
 262         if(EOF ==
 263         fputs("\n"
 264               "!if \"$(MANIFEST_LEVEL)\"==\"RULES\""
 265               "\n",
 266             pOutput))
 267     {
 268                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 269                 iRetval = 1;
 270         }
 271         return(iRetval);
 272 }
 273
 274 int output_end(FILE *pOutput)
 275 {
 276         int iRetval = 0;
 277
 278         if(EOF ==
 279         fputs("\n"
 280               "!endif"
 281               "\n",
 282             pOutput))
 283     {
 284                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 285                 iRetval = 1;
 286         }
 287         return(iRetval);
 288 }
 289
 290
 291 int buffer_to_output(char *pBuffer, FILE *pOutput)
 292 {
 293     int iRetval = 0;
 294     macro_list *pMacros = NULL;
 295
 296     /*  Tokenize the macros and their corresponding values.
 297      */
 298     pMacros = extract_macros(pBuffer);
 299     if(pMacros != NULL) {
 300         /*  Perform forward to backslash conversion on those macros known to be
 301          *      path information only.
 302          */
 303         slash_convert(pMacros, "JBOOTDIRS");
 304         slash_convert(pMacros, "JDIRS");
 305         slash_convert(pMacros, "DEPTH");
 306         slash_convert(pMacros, "NS_DEPTH");
 307         slash_convert(pMacros, "PACKAGE");
 308         slash_convert(pMacros, "JMC_GEN_DIR");
 309         slash_convert(pMacros, "DIST_PUBLIC");
 310
 311         /*  Process some of the macros, and convert them
 312          *      into different macros with different data.
 313          */
 314         morph_macro(&pMacros, "JMC_GEN", "JMC_HEADERS", "$(JMC_GEN_DIR)\\%s.h");
 315         morph_macro(&pMacros, "JMC_GEN", "JMC_STUBS", "$(JMC_GEN_DIR)\\%s.c");
 316         morph_macro(&pMacros, "JMC_GEN", "JMC_OBJS", ".\\$(OBJDIR)\\%s.obj");
 317         morph_macro(&pMacros, "CSRCS", "C_OBJS", ".\\$(OBJDIR)\\%s.obj");
 318         morph_macro(&pMacros, "CPPSRCS", "CPP_OBJS", ".\\$(OBJDIR)\\%s.obj");
 319         morph_macro(&pMacros, "REQUIRES", "LINCS", "-I$(XPDIST)\\public\\%s");
 320
 321         create_classroot( &pMacros );
 322
 323         /*  Output the Macros and the corresponding values.
 324          */
 325         iRetval = write_macros(pMacros, pOutput);
 326
 327         /*  Output rule file inclusion
 328          */
 329         if(iRetval == 0)    {
 330             iRetval = output_rules(pOutput);
 331         }
 332
 333         /*  Output explicit build rules/dependencies for JMC_GEN.
 334          */
 335         if(iRetval == 0)    {
 336             iRetval = explicit_rules(pMacros, "JMC_GEN", pOutput);
 337         }
 338
 339         if(iRetval == 0)    {
 340             iRetval = output_end(pOutput);
 341         }
 342         /*  Free off the macro list.
 343          */
 344         free_macro_list(pMacros);
 345         pMacros = NULL;
 346     }
 347
 348     return(iRetval);
 349 }
 350
 351 int explicit_rules(macro_list *pList, char *pMacro, FILE *pOutput)
 352 {
 353     int iRetval = 0;
 354     macro_list *pEntry = NULL;
 355
 356     if(pList == NULL || pMacro == NULL || pOutput == NULL) {
 357         return(0);
 358     }
 359
 360     /*  Find macro of said name.
 361      *  Case insensitive.
 362      */
 363     pEntry = pList;
 364     while(pEntry)    {
 365         if(stricmp(pEntry->m_pMacro, pMacro) == 0)  {
 366             break;
 367         }
 368
 369         pEntry = pEntry->m_pNext;
 370     }
 371
 372     if(pEntry)  {
 373         /*  Decide style of rule depending on macro name.
 374          */
 375         if(stricmp(pEntry->m_pMacro, "JMC_GEN") == 0)    {
 376             char_list *pNames = NULL;
 377             char *pModuleName = NULL;
 378             char *pClassName = NULL;
 379
 380             pNames = pEntry->m_pValue;
 381             while(pNames)   {
 382                 pModuleName = pNames->m_pString;
 383                 pClassName = pModuleName + 1;
 384
 385                 fprintf(pOutput, "$(JMC_GEN_DIR)\\%s.h", pModuleName);
 386                 fprintf(pOutput, ": ");
 387                 fprintf(pOutput, "$(JMCSRCDIR)\\%s.class", pClassName);
 388                 fprintf(pOutput, "\n    ");
 389                 fprintf(pOutput, "$(JMC) -d $(JMC_GEN_DIR) -interface $(JMC_GEN_FLAGS) $(?F:.class=)");
 390                 fprintf(pOutput, "\n");
 391
 392                 fprintf(pOutput, "$(JMC_GEN_DIR)\\%s.c", pModuleName);
 393                 fprintf(pOutput, ": ");
 394                 fprintf(pOutput, "$(JMCSRCDIR)\\%s.class", pClassName);
 395                 fprintf(pOutput, "\n    ");
 396                 fprintf(pOutput, "$(JMC) -d $(JMC_GEN_DIR) -module $(JMC_GEN_FLAGS) $(?F:.class=)");
 397                 fprintf(pOutput, "\n");
 398
 399                 pNames = pNames->m_pNext;
 400             }
 401         }
 402         else    {
 403             /*  Don't know how to format macro.
 404              */
 405             iRetval = 69;
 406         }
 407     }
 408
 409     return(iRetval);
 410 }
 411
 412 void slash_convert(macro_list *pList, char *pMacro)
 413 {
 414     macro_list *pEntry = NULL;
 415
 416     if(pList == NULL || pMacro == NULL) {
 417         return;
 418     }
 419
 420     /*  Find macro of said name.
 421      *  Case insensitive.
 422      */
 423     pEntry = pList;
 424     while(pEntry)    {
 425         if(stricmp(pEntry->m_pMacro, pMacro) == 0)  {
 426             break;
 427         }
 428
 429         pEntry = pEntry->m_pNext;
 430     }
 431
 432     if(pEntry)  {
 433         char *pConvert = NULL;
 434         char_list *pValue = pEntry->m_pValue;
 435
 436         while(pValue)   {
 437             pConvert = pValue->m_pString;
 438             while(pConvert && *pConvert)    {
 439                 if(*pConvert == '/')    {
 440                     *pConvert = '\\';
 441                 }
 442                 pConvert++;
 443             }
 444             pValue = pValue->m_pNext;
 445         }
 446     }
 447 }
 448
 449 void morph_macro(macro_list **ppList, char *pMacro, char *pMorph, char *pPrintf)
 450 {
 451     macro_list *pEntry = NULL;
 452
 453     if(ppList == NULL || pMacro == NULL || pMorph == NULL || pPrintf == NULL) {
 454         return;
 455     }
 456
 457     /*  Find macro of said name.
 458      *  Case insensitive.
 459      */
 460     pEntry = *ppList;
 461     while(pEntry)    {
 462         if(stricmp(pEntry->m_pMacro, pMacro) == 0)  {
 463             break;
 464         }
 465
 466         pEntry = pEntry->m_pNext;
 467     }
 468
 469     if(pEntry)  {
 470         char_list *pFilename = NULL;
 471         char aPath[_MAX_PATH];
 472         char aDrive[_MAX_DRIVE];
 473         char aDir[_MAX_DIR];
 474         char aFName[_MAX_FNAME];
 475         char aExt[_MAX_EXT];
 476         char *pBuffer = NULL;
 477
 478         /*  Start with buffer size needed.
 479          *  We expand this as we go along if needed.
 480          */
 481         pBuffer = (char *)malloc(strlen(pMorph) + 2);
 482         strcpy(pBuffer, pMorph);
 483         strcat(pBuffer, "=");
 484
 485         /*  Go through each value, converting over to new macro.
 486          */
 487         pFilename = pEntry->m_pValue;
 488         while(pFilename) {
 489             _splitpath(pFilename->m_pString, aDrive, aDir, aFName, aExt);
 490
 491             /*  Expand buffer by required amount.
 492              */
 493             sprintf(aPath, pPrintf, aFName);
 494             strcat(aPath, " ");
 495             pBuffer = (char *)realloc(pBuffer, _msize(pBuffer) + strlen(aPath));
 496             strcat(pBuffer, aPath);
 497
 498             pFilename = pFilename->m_pNext;
 499         }
 500
 501         /*  Add the macro.
 502          */
 503         add_macro(pBuffer, ppList);
 504
 505         free(pBuffer);
 506         pBuffer = NULL;
 507     }
 508 }
 509
 510 void create_classroot(macro_list **ppList )
 511 {
 512     char cwd[512];
 513     int i, i2;
 514     macro_list *pEntry = NULL;
 515     macro_list *pE;
 516
 517     /*  Find macro of said name.
 518      *  Case insensitive.
 519      */
 520     pEntry = *ppList;
 521     while(pEntry)    {
 522         if(stricmp(pEntry->m_pMacro, "PACKAGE") == 0)  {
 523             break;
 524         }
 525
 526         pEntry = pEntry->m_pNext;
 527     }
 528
 529     if(pEntry == 0 || pEntry->m_pValue == 0 || pEntry->m_pValue->m_pString == 0)  {
 530         return;
 531     }
 532
 533     _getcwd( cwd, 512 );
 534
 535     i = strlen( pEntry->m_pValue->m_pString );
 536     i2 = strlen( cwd );
 537
 538     cwd[i2-i-1] = 0;
 539
 540     pE = NULL;
 541     pE = (macro_list *)calloc(sizeof(macro_list),1);
 542     pE->m_pMacro = strdup("CLASSROOT");
 543     pE->m_pValue = (char_list *)calloc(sizeof(char_list),1);
 544     pE->m_pValue->m_pString = strdup(cwd);
 545
 546     while(*ppList)  {
 547         ppList = &((*ppList)->m_pNext);
 548     }
 549     *ppList = pE;
 550 }
 551
 552
 553 int write_macros(macro_list *pList, FILE *pOutput)
 554 {
 555     int iRetval = 0;
 556     int iLineLength = 0;
 557
 558     if(pList == NULL || pOutput == NULL)    {
 559         return(0);
 560     }
 561
 562         if(EOF ==
 563         fputs("\n"
 564               "!if \"$(MANIFEST_LEVEL)\"==\"MACROS\""
 565               "\n",
 566             pOutput))
 567     {
 568                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 569                 return(1);
 570         }
 571
 572     while(pList)    {
 573         int bIgnoreForWin16 = 0;
 574
 575         /* The following macros should not be emitted for Win16 */
 576         if (0 == strcmp(pList->m_pMacro, "LINCS")) {
 577             bIgnoreForWin16 = 1;
 578         }
 579
 580
 581         if (bIgnoreForWin16) {
 582             if(0 > fprintf(pOutput, "!if \"$(MOZ_BITS)\" != \"16\"\n"))  {
 583                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 584                 iRetval = 1;
 585                 break;
 586             }
 587         }
 588
 589         if(0 > fprintf(pOutput, "%s=", pList->m_pMacro))  {
 590                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 591             iRetval = 1;
 592             break;
 593         }
 594         iLineLength += strlen(pList->m_pMacro) + 1;
 595
 596         iRetval = write_values(pList->m_pValue, pOutput, iLineLength);
 597         if(iRetval) {
 598             break;
 599         }
 600
 601         if(EOF == fputc('\n', pOutput))    {
 602                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 603             iRetval = 1;
 604             break;
 605         }
 606         iLineLength = 0;
 607
 608         pList = pList->m_pNext;
 609
 610         if (bIgnoreForWin16) {
 611             if(0 > fprintf(pOutput, "!endif\n"))  {
 612                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 613                 iRetval = 1;
 614                 break;
 615             }
 616             bIgnoreForWin16 = 0;
 617         }
 618     }
 619
 620         if(EOF ==
 621         fputs("\n"
 622               "!endif"
 623               "\n",
 624             pOutput))
 625     {
 626                 fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 627                 return(1);
 628         }
 629     return(iRetval);
 630 }
 631
 632 int write_values(char_list *pList, FILE *pOutput, int iLineLength)
 633 {
 634     int iRetval = 0;
 635
 636     if(pList == NULL || pOutput == NULL)    {
 637         return(0);
 638     }
 639
 640     while(pList)    {
 641         if(iLineLength == 0)    {
 642             if(EOF == fputs("    ", pOutput))  {
 643                     fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 644                 iRetval = 1;
 645                 break;
 646             }
 647             iLineLength += 4;
 648
 649             if(0 > fprintf(pOutput, "%s ", pList->m_pString))   {
 650                     fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 651                 iRetval = 1;
 652                 break;
 653             }
 654             iLineLength += strlen(pList->m_pString) + 1;
 655         }
 656         else if(iLineLength + strlen(pList->m_pString) > 72)    {
 657             if(EOF == fputs("\\\n", pOutput)) {
 658                     fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 659                 iRetval = 1;
 660                 break;
 661             }
 662             iLineLength = 0;
 663             continue;
 664         }
 665         else    {
 666             if(0 > fprintf(pOutput, "%s ", pList->m_pString))   {
 667                     fprintf(stderr, "MANTOMAK:  Error writing to file....\n");
 668                 iRetval = 1;
 669                 break;
 670             }
 671             iLineLength += strlen(pList->m_pString) + 1;
 672         }
 673
 674         pList = pList->m_pNext;
 675     }
 676
 677     return(iRetval);
 678 }
 679
 680 macro_list *extract_macros(char *pBuffer)
 681 {
 682     macro_list *pRetval = NULL;
 683     char *pTraverse = NULL;
 684     char *pMacro = NULL;
 685
 686     pTraverse = pBuffer;
 687     while(pTraverse)    {
 688         pMacro = NULL;
 689         pTraverse = find_macro(pTraverse, &pMacro);
 690         if(pMacro)  {
 691             add_macro(pMacro, &pRetval);
 692         }
 693     }
 694
 695     return(pRetval);
 696 }
 697
 698 void add_macro(char *pString, macro_list **ppList)
 699 {
 700     macro_list *pEntry = NULL;
 701     int iLength = 0;
 702
 703     if(pString == NULL || *pString == '\0' || ppList == NULL) {
 704         return;
 705     }
 706
 707     /*  Allocate a new list entry for the macro.
 708      */
 709     pEntry = (macro_list *)calloc(1, sizeof(macro_list));
 710
 711     /*  Very first part of the string is the macro name.
 712      *  How long is it?
 713      */
 714     iLength = macro_length(pString);
 715     pEntry->m_pMacro = (char *)calloc(iLength + 1, 1);
 716     strncpy(pEntry->m_pMacro, pString, iLength);
 717
 718     /*  Skip to the values.
 719      *  These are always on the right side of an '='
 720      */
 721     pString = strchr(pString, '=');
 722     if(pString) {
 723         pString++;
 724     }
 725     add_values(pString, &(pEntry->m_pValue));
 726
 727     /*  Add the macro to the end of the macro list.
 728      */
 729     while(*ppList)  {
 730         ppList = &((*ppList)->m_pNext);
 731     }
 732     *ppList = pEntry;
 733 }
 734
 735 void add_values(char *pString, char_list **ppList)
 736 {
 737     char_list **ppTraverse = NULL;
 738     char_list *pEntry = NULL;
 739     int iLength = 0;
 740     int iBackslash = 0;
 741
 742     if(pString == NULL || *pString == '\0' || ppList == NULL)   {
 743         return;
 744     }
 745
 746     while(pString)  {
 747         /*  Find start of value.
 748          */
 749         iBackslash = 0;
 750         while(*pString) {
 751             if(*pString == '\\')    {
 752                 iBackslash++;
 753             }
 754             else if(*pString == '\n')   {
 755                 if(iBackslash == 0)  {
 756                     /*  End of values.
 757                      *  Setting to NULL gets out of all loops.
 758                      */
 759                     pString = NULL;
 760                     break;
 761                 }
 762                 iBackslash = 0;
 763             }
 764             else if(!isspace(*pString))  {
 765                 /*  Backslashes part of string.
 766                  *  This screws up if a backslash is in the middle of the string.
 767                  */
 768                 pString -= iBackslash;
 769                 break;
 770             }
 771
 772             pString++;
 773         }
 774         if(pString == NULL || *pString == '\0') {
 775             break;
 776         }
 777
 778         /*  Do not honor anything beginning with a #
 779          */
 780         if(*pString == '#') {
 781             /*  End of line.
 782              */
 783             while(*pString && *pString != '\n') {
 784                 pString++;
 785             }
 786             continue;
 787         }
 788
 789         /*  Very first part of the string is value name.
 790          *  How long is it?
 791          */
 792         iLength = value_length(pString);
 793
 794         /*  Do not honor $(NULL)
 795          */
 796         if(_strnicmp(pString, "$(NULL)", 7) == 0)    {
 797             pString += iLength;
 798             continue;
 799         }
 800
 801         /*  Allocate a new list entry for the next value.
 802          */
 803         pEntry = (char_list *)calloc(1, sizeof(char_list));
 804
 805         pEntry->m_pString = (char *)calloc(iLength + 1, 1);
 806         strncpy(pEntry->m_pString, pString, iLength);
 807
 808         /*  Add new value entry to the end of the list.
 809          */
 810         ppTraverse = ppList;
 811         while(*ppTraverse)  {
 812             ppTraverse = &((*ppTraverse)->m_pNext);
 813         }
 814         *ppTraverse = pEntry;
 815
 816         /*  Go on to next value.
 817          */
 818         pString += iLength;
 819     }
 820 }
 821
 822 char *find_macro(char *pBuffer, char **ppMacro)
 823 {
 824     char *pRetval = NULL;
 825     int iBackslash = 0;
 826
 827     if(pBuffer == NULL || ppMacro == NULL) {
 828         return(NULL);
 829     }
 830
 831     /*  Skip any whitespace in the buffer.
 832      *  If comments need to be skipped also, this is the place.
 833      */
 834     while(1)    {
 835         while(*pBuffer && isspace(*pBuffer))    {
 836             pBuffer++;
 837         }
 838         if(*pBuffer == '#') {
 839             /*  Go to the end of the line, it's a comment.
 840              */
 841             while(*pBuffer && *pBuffer != '\n') {
 842                 pBuffer++;
 843             }
 844
 845             continue;
 846         }
 847         break;
 848     }
 849
 850     if(*pBuffer)    {
 851         /*  Should be at the start of a macro.
 852          */
 853         *ppMacro = pBuffer;
 854     }
 855
 856     /*  Find the end of the macro for the return value.
 857      *  This is the end of a line which does not contain a backslash at the end.
 858      */
 859     while(*pBuffer) {
 860         if(*pBuffer == '\\')    {
 861             iBackslash++;
 862         }
 863         else if(*pBuffer == '\n')   {
 864             if(iBackslash == 0)  {
 865                 pRetval = pBuffer + 1;
 866                 break;
 867             }
 868             iBackslash = 0;
 869         }
 870         else if(!isspace(*pBuffer))  {
 871             iBackslash = 0;
 872         }
 873
 874         pBuffer++;
 875     }
 876
 877     return(pRetval);
 878 }
 879
 880 int macro_length(char *pMacro)
 881 {
 882     int iRetval = 0;
 883
 884     if(pMacro == NULL)  {
 885         return(0);
 886     }
 887
 888     /*  Length is no big deal.
 889      *  Problem is finding the end:
 890      *      whitespace
 891      *      '='
 892      */
 893     while(*pMacro)  {
 894         if(*pMacro == '=')  {
 895             break;
 896         }
 897         else if(isspace(*pMacro))   {
 898             break;
 899         }
 900
 901         pMacro++;
 902         iRetval++;
 903     }
 904
 905     return(iRetval);
 906 }
 907
 908 int value_length(char *pValue)
 909 {
 910     int iRetval = 0;
 911
 912     if(pValue == NULL)  {
 913         return(0);
 914     }
 915
 916     /*  Length is no big deal.
 917      *  Problem is finding the end:
 918      *      whitespace
 919      *      '\\'whitespace
 920      */
 921     while(*pValue)  {
 922         if(*pValue == '\\')  {
 923             char *pFindNewline = pValue + 1;
 924             /*  If whitespace to end of line, break here.
 925              */
 926             while(isspace(*pFindNewline))   {
 927                 if(*pFindNewline == '\n')   {
 928                     break;
 929                 }
 930                 pFindNewline++;
 931             }
 932             if(*pFindNewline == '\n')   {
 933                 break;
 934             }
 935         }
 936         else if(isspace(*pValue))   {
 937             break;
 938         }
 939
 940         pValue++;
 941         iRetval++;
 942     }
 943
 944     return(iRetval);
 945 }
 946
 947 char *skip_white(char *pString)
 948 {
 949     if(pString == NULL) {
 950         return(NULL);
 951     }
 952
 953     while(*pString && isspace(*pString)) {
 954         pString++;
 955     }
 956
 957     return(pString);
 958 }
 959
 960 void free_macro_list(macro_list *pList)
 961 {
 962     macro_list *pFree = NULL;
 963
 964     if(pList == NULL)   {
 965         return;
 966     }
 967
 968     while(pList)    {
 969         pFree = pList;
 970         pList = pList->m_pNext;
 971
 972         pFree->m_pNext = NULL;
 973
 974         free_char_list(pFree->m_pValue);
 975         pFree->m_pValue = NULL;
 976
 977         free(pFree->m_pMacro);
 978         pFree->m_pMacro = NULL;
 979
 980         free(pFree);
 981         pFree = NULL;
 982     }
 983 }
 984
 985 void free_char_list(char_list *pList)
 986 {
 987     char_list *pFree = NULL;
 988
 989     if(pList == NULL)   {
 990         return;
 991     }
 992
 993     while(pList)    {
 994         pFree = pList;
 995         pList = pList->m_pNext;
 996
 997         pFree->m_pNext = NULL;
 998
 999         free(pFree->m_pString);
1000         pFree->m_pString = NULL;
1001
1002         free(pFree);
1003         pFree = NULL;
1004     }
1005 }