Changeset 3123 for trunk/tools


Ignore:
Timestamp:
Mar 16, 2000, 4:27:08 PM (25 years ago)
Author:
bird
Message:

Changed to use internal list of dependencies which is flushed to disk
on when all files are searched.
This list is sorted, and don't allow two rules with the same name. The existing
rule has precedence. (This feature might come in handy when using OpusMake!)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tools/fastdep/fastdep.c

    r3122 r3123  
    1 /* $Id: fastdep.c,v 1.7 2000-03-15 17:14:16 bird Exp $
     1/* $Id: fastdep.c,v 1.8 2000-03-16 15:27:08 bird Exp $
    22 *
    33 * Fast dependents. (Fast = Quick and Dirty!)
    … …  
    8686 * Language specific analysis functions type.
    8787 */
    88 typedef int ( _FNLANG)  (FILE *phDep, const char *pszFilename, FILE *phFile,
     88typedef int ( _FNLANG)  (const char *pszFilename, FILE *phFile,
    8989                         BOOL fHeader, POPTIONS pOptions);
    9090typedef _FNLANG    *PFNLANG;
    … …  
    121121*******************************************************************************/
    122122static void syntax(void);
    123 static int makeDependent(FILE *phDep, const char *pszFilename, POPTIONS pOptions);
    124 
    125 int langC_CPP(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
    126 int langAsm(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
    127 int langRC(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
    128 int langCOBOL(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
     123static int makeDependent(const char *pszFilename, POPTIONS pOptions);
     124
     125int langC_CPP(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
     126int langAsm(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
     127int langRC(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
     128int langCOBOL(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions);
    129129
    130130
    … …  
    163163static BOOL  depReadFile(const char *pszFilename);
    164164static BOOL  depWriteFile(const char *pszFilename);
    165 static void *depAddRule(const char *pszRule);
     165static void  depRemoveAll(void);
     166static void *depAddRule(const char *pszRulePath, const char *pszName, const char *pszExt);
    166167static BOOL  depAddDepend(void *pvRule, const char *pszDep);
    167168
    … …  
    231232int main(int argc, char **argv)
    232233{
    233     FILE       *phDep = NULL;
    234234    int         rc   = 0;
    235235    int         argi = 1;
    … …  
    279279                case 'D':
    280280                case 'd': /* "-d <filename>" */
     281                {
     282                    const char *pszOld = pszDepFile;
    281283                    if (argv[argi][2] != '\0')
    282284                        pszDepFile = &argv[argi][2];
    … …  
    291293                        }
    292294                    }
    293                     if (phDep != NULL)
     295
     296                    /* if dependencies are generated we'll flush them to the old filename */
     297                    if (pdepList != NULL && pszOld != pszDepFile)
    294298                    {
    295                         fclose(phDep);
    296                         phDep = NULL;
     299                        if (!depWriteFile(pszOld))
     300                            fprintf(stderr, "error: failed to write (flush) dependencies.\n");
     301                        depRemoveAll();
    297302                    }
    298303                    break;
     304                }
    299305
    300306                case 'E': /* list of paths. If a file is found in one of these directories the */
    … …  
    416422
    417423            /*
    418              * Open output file.
    419              */
    420             if (phDep == NULL)
    421             {
    422                 phDep = fopen(pszDepFile, options.fAppend ? "a" : "w");
    423                 if (phDep == NULL)
    424                 {
    425                     fprintf(stderr, "error opening outputfile '%s'.\n", pszDepFile);
    426                     return 1;
    427                 }
    428             }
    429 
    430             /*
    431424             * Search for the files specified.
    432425             */
    … …  
    454447                 * Analyse the file.
    455448                 */
    456                 rc -= makeDependent(phDep, &szSource[0], &options);
     449                rc -= makeDependent(&szSource[0], &options);
    457450
    458451                /* next file */
    … …  
    465458    }
    466459
    467     /* Close the dep file! */
    468     if (phDep != NULL)
    469         fclose(phDep);
    470 
    471     /* clean it! */
    472     #if 0
    473     depCleanFile(pszDepFile);
    474     #endif
     460    /* Write the depend file! */
     461    if (!depWriteFile(pszDepFile))
     462        fprintf(stderr, "error: failed to write dependencies file!\n");
    475463
    476464    return rc;
    … …  
    519507
    520508/**
    521  * Generates depend info on this file, and fwrites it to phDep.
     509 * Generates depend info on this file, these are stored internally
     510 * and written to file later.
    522511 * @returns
    523  * @param     phDep        Pointer to file struct for outfile.
    524512 * @param     pszFilename  Pointer to source filename.
    525513 * @param     pOptions     Pointer to options struct.
    … …  
    527515 * @author    knut st. osmundsen
    528516 */
    529 static int makeDependent(FILE *phDep, const char *pszFilename, POPTIONS pOptions)
     517static int makeDependent(const char *pszFilename, POPTIONS pOptions)
    530518{
    531519    int    rc = -1;
    … …  
    558546        /* Found? */
    559547        if (pCfg->papszExts != NULL)
    560             rc = (*pCfg->pfn)(phDep, pszFilename, phFile, fHeader, pOptions);
     548            rc = (*pCfg->pfn)(pszFilename, phFile, fHeader, pOptions);
    561549        else
    562550        {
    … …  
    566554        }
    567555
    568         fputs("\n", phDep);
    569556        fclose(phFile);
    570557    }
    … …  
    577564
    578565/**
    579  * Generates depend info on this C or C++ file, and writes it to phDep.
     566 * Generates depend info on this C or C++ file, these are stored internally
     567 * and written to file later.
    580568 * @returns   0 on success.
    581569 *            !0 on error.
    582  * @param     phDep        Pointer to file struct for outfile.
    583570 * @param     pszFilename  Pointer to source filename.
    584571 * @param     phFile       Pointer to source file handle.
    … …  
    587574 * @author    knut st. osmundsen
    588575 */
    589 int langC_CPP(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
    590 {
     576int langC_CPP(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
     577{
     578    void *  pvRule;                     /* Handle to the current rule. */
    591579    int     iLine;                      /* Linenumber. */
    592580    char    szBuffer[4096];             /* Max line length is 4096... should not be a problem. */
    … …  
    608596
    609597    /**********************************/
    610     /* print file name to depend file */
     598    /* Add the depend rule            */
    611599    /**********************************/
    612600    if (pOptions->fObjRule && !fHeader)
    613601    {
    614602        if (pOptions->fNoObjectPath)
    615             fprintf(phDep, "%s.%s:", fileNameNoExt(pszFilename, szBuffer), pOptions->pszObjectExt);
     603            pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszObjectExt);
    616604        else
    617             fprintf(phDep, "%s%s.%s:",
    618                     pOptions->fObjectDir ?
    619                         pOptions->pszObjectDir : filePathSlash(pszFilename, szBuffer),
    620                     fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
    621                     pOptions->pszObjectExt);
    622 
    623         if (pOptions->fSrcWhenObj)
    624             fprintf(phDep, " \\\n%4s %s", "",
    625                     pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename
    626                     );
     605            pvRule = depAddRule(pOptions->fObjectDir ?
     606                                    pOptions->pszObjectDir :
     607                                    filePathSlash(pszFilename, szBuffer),
     608                                fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
     609                                pOptions->pszObjectExt);
     610
     611        if (pOptions->fSrcWhenObj && pvRule)
     612            depAddDepend(pvRule, pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename);
    627613    }
    628614    else
    629         fprintf(phDep, "%s:", pszFilename);
     615        pvRule = depAddRule(pszFilename, NULL, NULL);
     616
     617    /* duplicate rule? */
     618    if (pvRule == NULL)
     619        return 0;
    630620
    631621
    … …  
    726716                        if (psz != NULL)
    727717                        {
    728                             char szBuffer2[CCHMAXPATH];
     718                            char    szBuffer2[CCHMAXPATH];
    729719                            if (pOptions->fExcludeAll ||
    730720                                pathlistFindFile(pOptions->pszExclude, szFullname, szBuffer2) != NULL
    731721                                )
    732                                 strcpy(szBuffer, szFullname);
    733                             fprintf(phDep, " \\\n%4.s %s", "", szBuffer);
     722                                depAddDepend(pvRule, szFullname);
     723                            else
     724                                depAddDepend(pvRule, szBuffer);
    734725                        }
    735726                        else
    … …  
    848839            break;
    849840    } /*while*/
    850     fputs("\n", phDep);
    851841
    852842    return 0;
    … …  
    855845
    856846/**
    857  * Generates depend info on this file, and fwrites it to phDep.
     847 * Generates depend info on this file, these are stored internally
     848 * and written to file later.
    858849 * @returns   0 on success.
    859850 *            !0 on error.
    860  * @param     phDep        Pointer to file struct for outfile.
    861851 * @param     pszFilename  Pointer to source filename.
    862852 * @param     phFile       Pointer to source file handle.
    … …  
    865855 * @author    knut st. osmundsen
    866856 */
    867 int langAsm(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
    868 {
    869     char szBuffer[4096]; /* max line length */
    870     int  iLine;
     857int langAsm(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
     858{
     859    void *  pvRule;                     /* Handle to the current rule. */
     860    char    szBuffer[4096];             /* Temporary buffer (max line lenght size...) */
     861    int     iLine;                      /* current line number */
    871862
    872863
    873864    /**********************************/
    874     /* print file name to depend file */
     865    /* Add the depend rule            */
    875866    /**********************************/
    876867    if (pOptions->fObjRule && !fHeader)
    877868    {
    878869        if (pOptions->fNoObjectPath)
    879             fprintf(phDep, "%s.%s:", fileNameNoExt(pszFilename, szBuffer), pOptions->pszObjectExt);
     870            pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszObjectExt);
    880871        else
    881             fprintf(phDep, "%s%s.%s:",
    882                     pOptions->fObjectDir ?
    883                         pOptions->pszObjectDir : filePathSlash(pszFilename, szBuffer),
    884                     fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
    885                     pOptions->pszObjectExt);
    886 
    887         if (pOptions->fSrcWhenObj)
    888             fprintf(phDep, " \\\n%4s %s", "",
    889                     pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename
    890                     );
     872            pvRule = depAddRule(pOptions->fObjectDir ?
     873                                    pOptions->pszObjectDir :
     874                                    filePathSlash(pszFilename, szBuffer),
     875                                fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
     876                                pOptions->pszObjectExt);
     877
     878        if (pOptions->fSrcWhenObj && pvRule)
     879            depAddDepend(pvRule, pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename);
    891880    }
    892881    else
    893         fprintf(phDep, "%s:", pszFilename);
     882        pvRule = depAddRule(pszFilename, NULL, NULL);
     883
     884    /* duplicate rule? */
     885    if (pvRule == NULL)
     886        return 0;
    894887
    895888
    … …  
    954947                        pathlistFindFile(pOptions->pszExclude, szFullname, szBuffer2) != NULL
    955948                        )
    956                         strcpy(szBuffer, szFullname);
    957                     fprintf(phDep, " \\\n%4.s %s", "", szBuffer);
     949                        depAddDepend(pvRule, szFullname);
     950                    else
     951                        depAddDepend(pvRule, szBuffer);
    958952                }
    959953                else
    … …  
    965959            break;
    966960    } /*while*/
    967     fputs("\n", phDep);
    968961
    969962    return 0;
    … …  
    972965
    973966/**
    974  * Generates depend info on this Resource file, and writes it to phDep.
     967 * Generates depend info on this Resource file, these are stored internally
     968 * and written to file later.
    975969 * @returns   0 on success.
    976970 *            !0 on error.
    977  * @param     phDep        Pointer to file struct for outfile.
    978971 * @param     pszFilename  Pointer to source filename.
    979972 * @param     phFile       Pointer to source file handle.
    … …  
    982975 * @author    knut st. osmundsen
    983976 */
    984 int langRC(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
    985 {
    986     char szBuffer[4096]; /* max line length */
    987     int  iLine;
     977int langRC(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
     978{
     979    void *  pvRule;                     /* Handle to the current rule. */
     980    char    szBuffer[4096];             /* Temporary buffer (max line lenght size...) */
     981    int     iLine;                      /* current line number */
     982
    988983
    989984    /**********************************/
    990     /* print file name to depend file */
     985    /* Add the depend rule            */
    991986    /**********************************/
    992987    if (pOptions->fObjRule && !fHeader)
    993988    {
    994989        if (pOptions->fNoObjectPath)
    995             fprintf(phDep, "%s.%s:", fileNameNoExt(pszFilename, szBuffer), pOptions->pszRsrcExt);
     990            pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszRsrcExt);
    996991        else
    997             fprintf(phDep, "%s%s.res:",
    998                     pOptions->fObjectDir ?
    999                         pOptions->pszObjectDir : filePathSlash(pszFilename, szBuffer),
    1000                     fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
    1001                     pOptions->pszRsrcExt);
    1002 
    1003         if (pOptions->fSrcWhenObj)
    1004             fprintf(phDep, " \\\n%4s %s", "",
    1005                     pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename
    1006                     );
     992            pvRule = depAddRule(pOptions->fObjectDir ?
     993                                    pOptions->pszObjectDir :
     994                                    filePathSlash(pszFilename, szBuffer),
     995                                fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
     996                                pOptions->pszRsrcExt);
     997
     998        if (pOptions->fSrcWhenObj && pvRule)
     999            depAddDepend(pvRule, pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename);
    10071000    }
    10081001    else
    1009         fprintf(phDep, "%s:", pszFilename);
     1002        pvRule = depAddRule(pszFilename, NULL, NULL);
     1003
     1004    /* duplicate rule? */
     1005    if (pvRule == NULL)
     1006        return 0;
    10101007
    10111008
    … …  
    10721069                        pathlistFindFile(pOptions->pszExclude, szFullname, szBuffer2) != NULL
    10731070                        )
    1074                         strcpy(szBuffer, szFullname);
    1075                     fprintf(phDep, " \\\n%4.s %s", "", szBuffer);
     1071                        depAddDepend(pvRule, szFullname);
     1072                    else
     1073                        depAddDepend(pvRule, szBuffer);
    10761074                }
    10771075                else
    … …  
    10831081            break;
    10841082    } /*while*/
    1085     fputs("\n", phDep);
    10861083
    10871084    return 0;
    … …  
    10901087
    10911088/**
    1092  * Generates depend info on this COBOL file, and writes it to phDep.
     1089 * Generates depend info on this COBOL file, these are stored internally
     1090 * and written to file later.
    10931091 * @returns   0 on success.
    10941092 *            !0 on error.
    1095  * @param     phDep        Pointer to file struct for outfile.
    10961093 * @param     pszFilename  Pointer to source filename.
    10971094 * @param     phFile       Pointer to source file handle.
    … …  
    11001097 * @author    knut st. osmundsen
    11011098 */
    1102 int langCOBOL(FILE *phDep, const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
    1103 {
    1104     char szBuffer[4096]; /* max line length */
    1105     int  iLine;
     1099int langCOBOL(const char *pszFilename, FILE *phFile, BOOL fHeader, POPTIONS pOptions)
     1100{
     1101    void *  pvRule;                     /* Handle to the current rule. */
     1102    char    szBuffer[4096];             /* Temporary buffer (max line lenght size...) */
     1103    int     iLine;                      /* current line number */
     1104
    11061105
    11071106    /**********************************/
    1108     /* print file name to depend file */
     1107    /* Add the depend rule            */
    11091108    /**********************************/
    11101109    if (pOptions->fObjRule && !fHeader)
    11111110    {
    11121111        if (pOptions->fNoObjectPath)
    1113             fprintf(phDep, "%s.%s:", fileNameNoExt(pszFilename, szBuffer), pOptions->pszObjectExt);
     1112            pvRule = depAddRule(fileNameNoExt(pszFilename, szBuffer), NULL, pOptions->pszObjectExt);
    11141113        else
    1115             fprintf(phDep, "%s%s.%s:",
    1116                     pOptions->fObjectDir ?
    1117                         pOptions->pszObjectDir : filePathSlash(pszFilename, szBuffer),
    1118                     fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
    1119                     pOptions->pszObjectExt);
    1120 
    1121         if (pOptions->fSrcWhenObj)
    1122             fprintf(phDep, " \\\n%4s %s", "",
    1123                     pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename
    1124                     );
     1114            pvRule = depAddRule(pOptions->fObjectDir ?
     1115                                    pOptions->pszObjectDir :
     1116                                    filePathSlash(pszFilename, szBuffer),
     1117                                fileNameNoExt(pszFilename, szBuffer + CCHMAXPATH),
     1118                                pOptions->pszObjectExt);
     1119
     1120        if (pOptions->fSrcWhenObj && pvRule)
     1121            depAddDepend(pvRule, pOptions->fExcludeAll ? fileName(pszFilename, szBuffer) : pszFilename);
    11251122    }
    11261123    else
    1127         fprintf(phDep, "%s:", pszFilename);
     1124        pvRule = depAddRule(pszFilename, NULL, NULL);
     1125
     1126    /* duplicate rule? */
     1127    if (pvRule == NULL)
     1128        return 0;
    11281129
    11291130
    … …  
    12201221                        pathlistFindFile(pOptions->pszExclude, szFullname, szBuffer2) != NULL
    12211222                        )
    1222                         strcpy(szBuffer, szFullname);
    1223                     fprintf(phDep, " \\\n%4.s %s", "", szBuffer);
     1223                        depAddDepend(pvRule, szFullname);
     1224                    else
     1225                        depAddDepend(pvRule, szBuffer);
    12241226                }
    12251227                else
    … …  
    12311233            break;
    12321234    } /*while*/
    1233     fputs("\n", phDep);
    12341235
    12351236    return 0;
    … …  
    17071708        if (!fMoreDeps && *psz != ' ' && *psz != '\t' && *psz != '\0')
    17081709        {
     1710            i = 0;
    17091711            while (psz[i] != '\0')
    17101712            {
    … …  
    17231725            {   /* new rule! */
    17241726                psz[i] = '\0';
    1725                 pvRule = depAddRule(trimR(psz));
     1727                pvRule = depAddRule(trimR(psz), NULL, NULL);
    17261728                psz += i + 1;
    17271729                cch -= i + 1;
    … …  
    17401742            else
    17411743                fMoreDeps = FALSE;
    1742             psz = trim(psz);
    1743             if (*psz != '\0')
    1744                 depAddDepend(pvRule, psz);
     1744
     1745            /* if not duplicate rule */
     1746            if (pvRule != NULL)
     1747            {
     1748                psz = trim(psz);
     1749                if (*psz != '\0')
     1750                    depAddDepend(pvRule, psz);
     1751            }
    17451752        }
    17461753    } /* while */
    … …  
    17631770    if (phFile != NULL)
    17641771    {
     1772        char     szBuffer[4096];
     1773        int      iBuffer = 0;
    17651774        PDEPRULE pdep = pdepList;
     1775
    17661776        while (pdep != NULL)
    17671777        {
    1768 
    1769             fprintf(phFile, "%s:", pdep->pszRule);
     1778            /* Write rule. Flush the buffer first if necessary. */
     1779            if (iBuffer + 2 >= sizeof(szBuffer))
     1780            {
     1781                fwrite(szBuffer, iBuffer, 1, phFile);
     1782                iBuffer = 0;
     1783            }
     1784            iBuffer += sprintf(szBuffer + iBuffer, "%s:", pdep->pszRule);
     1785
     1786            /* write rule dependants. */
    17701787            if (pdep->papszDep != NULL)
    17711788            {
    … …  
    17731790                while (*ppsz != NULL)
    17741791                {
    1775                     fprintf(phFile, " \\\n    %s", *ppsz);
     1792                    /* flush buffer? */
     1793                    if (iBuffer + strlen(*ppsz) + 20 >= sizeof(szBuffer))
     1794                    {
     1795                        fwrite(szBuffer, iBuffer, 1, phFile);
     1796                        iBuffer = 0;
     1797                    }
     1798                    iBuffer += sprintf(szBuffer + iBuffer, " \\\n    %s", *ppsz);
    17761799
    17771800                    /* next dependant */
    … …  
    17791802                }
    17801803            }
    1781             fputs("\n\n", phFile);
     1804
     1805            /* Add two new lines. Flush buffer first if necessary. */
     1806            if (iBuffer + 2 >= sizeof(szBuffer))
     1807            {
     1808                fwrite(szBuffer, iBuffer, 1, phFile);
     1809                iBuffer = 0;
     1810            }
     1811            strcpy(szBuffer + iBuffer, "\n\n");
     1812            iBuffer += 2;
    17821813
    17831814            /* next rule */
    … …  
    17851816        }
    17861817
     1818        /* flush buffer. */
     1819        fwrite(szBuffer, iBuffer, 1, phFile);
     1820
    17871821        fclose(phFile);
    17881822        return TRUE;
    … …  
    17921826}
    17931827
     1828
     1829/**
     1830 * Removes all entries in the list of dependencies. (pdepList)
     1831 */
     1832static void  depRemoveAll(void)
     1833{
     1834    while (pdepList != NULL)
     1835    {
     1836        register PDEPRULE pdepToBeFree = pdepList;
     1837        /* next */
     1838        pdepList = pdepToBeFree->pNext;
     1839
     1840        /* free this */
     1841        if (pdepToBeFree->papszDep != NULL)
     1842        {
     1843            char ** ppsz = pdepToBeFree->papszDep;
     1844            while (*ppsz != NULL)
     1845                free(*ppsz++);
     1846            free(pdepToBeFree->papszDep);
     1847        }
     1848        free(pdepToBeFree);
     1849    }
     1850}
     1851
     1852
    17941853/**
    17951854 * Adds a rule to the list of dependant rules.
    17961855 * @returns   Rule handle. NULL if rule exists/error.
    1797  * @param     pszRule   Pointer to rule text. Empty strings are banned!
    1798  *
    1799  */
    1800 static void *depAddRule(const char *pszRule)
    1801 {
     1856 * @param     pszRulePath   Pointer to rule text. Empty strings are banned!
     1857 *                          This string might only contain the path of the rule. (with '\\')
     1858 * @param     pszName       Name of the rule.
     1859 *                          NULL if pszRulePath contains the entire rule.
     1860 * @param     pszExt        Extention (without '.')
     1861 *                          NULL if pszRulePath or pszRulePath and pszName contains the entire rule.
     1862 */
     1863static void *depAddRule(const char *pszRulePath, const char *pszName, const char *pszExt)
     1864{
     1865    char     szRule[CCHMAXPATH*2];
    18021866    PDEPRULE pdepPrev = NULL;
    18031867    PDEPRULE pdep = pdepList;
    18041868    PDEPRULE pNew;
     1869    int      cch;
     1870
     1871    /* make rulename */
     1872    strcpy(szRule, pszRulePath);
     1873    cch = strlen(szRule);
     1874    if (pszName != NULL)
     1875    {
     1876        strcpy(szRule + cch, pszName);
     1877        cch += strlen(szRule + cch);
     1878    }
     1879    if (pszExt != NULL)
     1880    {
     1881        strcat(szRule + cch++, ".");
     1882        strcat(szRule + cch, pszExt);
     1883        cch += strlen(szRule + cch);
     1884    }
    18051885
    18061886    /* find location */
    1807     while (pdep != NULL &&
    1808            stricmp(pdep->pszRule, pszRule) < 0
    1809            )
    1810     {
    1811         pdep = pdepPrev;
     1887    while (pdep != NULL && stricmp(pdep->pszRule, szRule) < 0)
     1888    {
     1889        pdepPrev = pdep;
    18121890        pdep = pdep->pNext;
    18131891    }
    18141892
    18151893    /* check if matching rule name */
    1816     if (pdep != NULL && stricmp(pdep->pszRule, pszRule) == 0)
     1894    if (pdep != NULL && stricmp(pdep->pszRule, szRule) == 0)
    18171895        return NULL;
    18181896
    1819     /* allocate a new rule structure and fill in data */
    1820     pNew = malloc(sizeof(DEPRULE));
     1897    /*
     1898     * Allocate a new rule structure and fill in data
     1899     * Note. One block for both the DEPRULE and the pszRule string.
     1900     */
     1901    pNew = malloc(sizeof(DEPRULE) + cch + 1);
    18211902    if (pNew == NULL)
    18221903        return NULL;
    1823     pNew->pszRule = malloc(strlen(pszRule) + 1);
    1824     if (pNew->pszRule == NULL)
    1825     {
    1826         free(pNew);
    1827         return NULL;
    1828     }
    1829     strcpy(pNew->pszRule, pszRule);
     1904    pNew->pszRule = (char*)(void*)(pNew + 1);
     1905    strcpy(pNew->pszRule, szRule);
    18301906    pNew->cDeps = 0;
    18311907    pNew->papszDep = NULL;
    … …  
    18541930
    18551931    /* allocate more array space */
    1856     if (pdep->cDeps == 0 || (pdep->cDeps + 2) % 32 == 0)
    1857     {
    1858         pdep->papszDep = realloc(pdep->papszDep, 32 * sizeof(char*));
     1932    if (pdep->cDeps == 0 || ((pdep->cDeps + 2) % 32) == 0)
     1933    {
     1934        pdep->papszDep = realloc(pdep->papszDep, sizeof(char*) * (pdep->cDeps + 32));
    18591935        if (pdep->papszDep == NULL)
    18601936        {
Note: See TracChangeset for help on using the changeset viewer.