VirtualBox

Changeset 1045 in kBuild for trunk/src/kObjCache/kObjCache.c


Ignore:
Timestamp:
Jun 9, 2007 4:44:19 AM (18 years ago)
Author:
bird
Message:

fixing more bugs. it sort of works now.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kObjCache/kObjCache.c

    r1044 r1045  
    10911091    free(pEntry->Old.pszObjName);
    10921092
     1093    free(pEntry->New.pszTarget);
     1094    free(pEntry->Old.pszTarget);
     1095
    10931096    while (pEntry->New.cArgvCompile > 0)
    10941097        free(pEntry->New.papszArgvCompile[--pEntry->New.cArgvCompile]);
    … …  
    11041107
    11051108/**
     1109 * Calculates the checksum of an compiler argument vector.
     1110 *
     1111 * @param   pEntry          The cache entry.
     1112 * @param   papszArgv       The argument vector.
     1113 * @param   cArgc           The number of entries in the vector.
     1114 * @param   pszIgnorePath   Path to ignore when encountered at the end of arguments.
     1115 *                          (Not quite safe for simple file names, but what the heck.)
     1116 * @param   pSum            Where to store the check sum.
     1117 */
     1118static void kOCEntryCalcArgvSum(PKOCENTRY pEntry, const char * const *papszArgv, unsigned cArgc,
     1119                                const char *pszIgnorePath, PKOCSUM pSum)
     1120{
     1121    size_t cchIgnorePath = strlen(pszIgnorePath);
     1122    KOCSUMCTX Ctx;
     1123    unsigned i;
     1124
     1125    kOCSumInitWithCtx(pSum, &Ctx);
     1126    for (i = 0; i < cArgc; i++)
     1127    {
     1128        size_t cch = strlen(papszArgv[i]);
     1129        if (    cch < cchIgnorePath
     1130            ||  !ArePathsIdentical(papszArgv[i] + cch - cchIgnorePath, pszIgnorePath, cch))
     1131            kOCSumUpdate(pSum, &Ctx, papszArgv[i], cch + 1);
     1132    }
     1133    kOCSumFinalize(pSum, &Ctx);
     1134}
     1135
     1136
     1137/**
    11061138 * Reads and parses the cache file.
    11071139 *
    … …  
    11141146    if (pFile)
    11151147    {
    1116         InfoMsg(1, "reading cache file...\n");
     1148        InfoMsg(4, "reading cache entry...\n");
    11171149
    11181150        /*
    … …  
    11221154            ||  strcmp(g_szLine, "magic=kObjCache-1\n"))
    11231155        {
    1124             InfoMsg(1, "bad cache file (magic)\n");
     1156            InfoMsg(2, "bad cache file (magic)\n");
    11251157            pEntry->fNeedCompiling = 1;
    11261158        }
    … …  
    12311263            if (!fBad && fBadBeforeMissing)
    12321264            {
    1233                 InfoMsg(1, "bad cache file (no end)\n");
     1265                InfoMsg(2, "bad cache file (no end)\n");
    12341266                fBad = 1;
    12351267            }
    … …  
    12441276                    fBad = 1;
    12451277                if (!fBad)
    1246                 {
    1247                     KOCSUMCTX Ctx;
    1248                     KOCSUM Sum;
    1249 
    1250                     kOCSumInitWithCtx(&Sum, &Ctx);
    12511278                    for (i = 0; i < pEntry->Old.cArgvCompile; i++)
    1252                     {
    12531279                        if ((fBad = !pEntry->Old.papszArgvCompile[i]))
    12541280                            break;
    1255                         kOCSumUpdate(&Sum, &Ctx, pEntry->Old.papszArgvCompile[i], strlen(pEntry->Old.papszArgvCompile[i]) + 1);
    1256                     }
    1257                     kOCSumFinalize(&Sum, &Ctx);
    1258                     if (!fBad)
    1259                         fBad = !kOCSumIsEqual(&pEntry->Old.SumCompArgv, &Sum);
     1281                if (!fBad)
     1282                {
     1283                    KOCSUM Sum;
     1284                    kOCEntryCalcArgvSum(pEntry, (const char * const *)pEntry->Old.papszArgvCompile,
     1285                                        pEntry->Old.cArgvCompile, pEntry->Old.pszObjName, &Sum);
     1286                    fBad = !kOCSumIsEqual(&pEntry->Old.SumCompArgv, &Sum);
    12601287                }
    12611288                if (fBad)
    1262                     InfoMsg(1, "bad cache file (%s)\n", fBadBeforeMissing ? g_szLine : "missing stuff");
     1289                    InfoMsg(2, "bad cache file (%s)\n", fBadBeforeMissing ? g_szLine : "missing stuff");
    12631290                else if (ferror(pFile))
    12641291                {
    1265                     InfoMsg(1, "cache file read error\n");
     1292                    InfoMsg(2, "cache file read error\n");
    12661293                    fBad = 1;
    12671294                }
    … …  
    12761303                    if (stat(pszPath, &st) != 0)
    12771304                    {
    1278                         InfoMsg(1, "failed to stat object file: %s\n", strerror(errno));
     1305                        InfoMsg(2, "failed to stat object file: %s\n", strerror(errno));
    12791306                        fBad = 1;
    12801307                    }
    … …  
    12911318    else
    12921319    {
    1293         InfoMsg(1, "no cache file\n");
     1320        InfoMsg(2, "no cache file\n");
    12941321        pEntry->fNeedCompiling = 1;
    12951322    }
    … …  
    13081335    unsigned i;
    13091336
    1310     InfoMsg(1, "writing cache entry '%s'...\n", pEntry->pszName);
     1337    InfoMsg(4, "writing cache entry '%s'...\n", pEntry->pszName);
    13111338    pFile = FOpenFileInDir(pEntry->pszName, pEntry->pszDir, "wb");
    13121339    if (!pFile)
    … …  
    13821409static int kOCEntryCheck(PKOCENTRY pEntry)
    13831410{
    1384     return pEntry->fNeedCompiling;
     1411    return !pEntry->fNeedCompiling;
     1412}
     1413
     1414
     1415/**
     1416 * Sets the object name and compares it with the old name if present.
     1417 *
     1418 * @param   pEntry      The cache entry.
     1419 * @param   pszObjName  The new object name.
     1420 */
     1421static void kOCEntrySetCompileObjName(PKOCENTRY pEntry, const char *pszObjName)
     1422{
     1423    assert(!pEntry->New.pszObjName);
     1424    pEntry->New.pszObjName = CalcRelativeName(pszObjName, pEntry->pszDir);
     1425
     1426    if (    !pEntry->fNeedCompiling
     1427        &&  (   !pEntry->Old.pszObjName
     1428             || strcmp(pEntry->New.pszObjName, pEntry->Old.pszObjName)))
     1429    {
     1430        InfoMsg(2, "object file name differs\n");
     1431        pEntry->fNeedCompiling = 1;
     1432    }
     1433
     1434    if (    !pEntry->fNeedCompiling
     1435        &&  !DoesFileInDirExist(pEntry->New.pszObjName, pEntry->pszDir))
     1436    {
     1437        InfoMsg(2, "object file doesn't exist\n");
     1438        pEntry->fNeedCompiling = 1;
     1439    }
    13851440}
    13861441
    … …  
    13921447 * @param   papszArgvCompile    The new argument vector for compilation.
    13931448 * @param   cArgvCompile        The number of arguments in the vector.
     1449 *
     1450 * @remark  Must call kOCEntrySetCompileObjName before this function!
    13941451 */
    13951452static void kOCEntrySetCompileArgv(PKOCENTRY pEntry, const char * const *papszArgvCompile, unsigned cArgvCompile)
    13961453{
    1397     KOCSUMCTX Ctx;
    13981454    unsigned i;
    13991455
    14001456    /* call me only once! */
    14011457    assert(!pEntry->New.cArgvCompile);
    1402 
    1403     /*
    1404      * Copy the argument vector and calculate the checksum while doing so.
     1458    /* call kOCEntrySetCompilerObjName first! */
     1459    assert(pEntry->New.pszObjName);
     1460
     1461    /*
     1462     * Copy the argument vector and calculate the checksum.
    14051463     */
    14061464    pEntry->New.cArgvCompile = cArgvCompile;
    14071465    pEntry->New.papszArgvCompile = xmalloc((cArgvCompile + 1) * sizeof(pEntry->New.papszArgvCompile[0]));
    1408     kOCSumInitWithCtx(&pEntry->New.SumCompArgv, &Ctx);
    14091466    for (i = 0; i < cArgvCompile; i++)
    1410     {
    14111467        pEntry->New.papszArgvCompile[i] = xstrdup(papszArgvCompile[i]);
    1412         kOCSumUpdate(&pEntry->New.SumCompArgv, &Ctx, papszArgvCompile[i], strlen(papszArgvCompile[i]) + 1);
    1413     }
    1414     kOCSumFinalize(&pEntry->New.SumCompArgv, &Ctx);
    14151468    pEntry->New.papszArgvCompile[i] = NULL; /* for exev/spawnv */
    1416     kOCSumInfo(&pEntry->New.SumCompArgv, 1, "comp-argv");
     1469
     1470    kOCEntryCalcArgvSum(pEntry, papszArgvCompile, cArgvCompile, pEntry->New.pszObjName, &pEntry->New.SumCompArgv);
     1471    kOCSumInfo(&pEntry->New.SumCompArgv, 4, "comp-argv");
    14171472
    14181473    /*
    … …  
    14221477        &&  !kOCSumIsEqual(&pEntry->New.SumCompArgv, &pEntry->Old.SumCompArgv))
    14231478    {
    1424         InfoMsg(1, "compiler args differs\n");
    1425         pEntry->fNeedCompiling = 1;
    1426     }
    1427 }
    1428 
    1429 
    1430 /**
    1431  * Sets the object name and compares it with the old name if present.
    1432  *
    1433  * @param   pEntry      The cache entry.
    1434  * @param   pszObjName  The new object name.
    1435  */
    1436 static void kOCEntrySetCompileObjName(PKOCENTRY pEntry, const char *pszObjName)
    1437 {
    1438     assert(!pEntry->New.pszObjName);
    1439     pEntry->New.pszObjName = CalcRelativeName(pszObjName, pEntry->pszDir);
    1440 
    1441     if (    !pEntry->fNeedCompiling
    1442         &&  (   !pEntry->Old.pszObjName
    1443              || strcmp(pEntry->New.pszObjName, pEntry->Old.pszObjName)))
    1444     {
    1445         InfoMsg(1, "object file name differs\n");
    1446         pEntry->fNeedCompiling = 1;
    1447     }
    1448 
    1449     if (    !pEntry->fNeedCompiling
    1450         &&  !DoesFileInDirExist(pEntry->New.pszObjName, pEntry->pszDir))
    1451     {
    1452         InfoMsg(1, "object file doesn't exist\n");
     1479        InfoMsg(2, "compiler args differs\n");
    14531480        pEntry->fNeedCompiling = 1;
    14541481    }
    … …  
    14711498             || strcmp(pEntry->New.pszTarget, pEntry->Old.pszTarget)))
    14721499    {
    1473         InfoMsg(1, "target differs\n");
     1500        InfoMsg(2, "target differs\n");
    14741501        pEntry->fNeedCompiling = 1;
    14751502    }
    … …  
    16871714    int iStatus = -1;
    16881715    pid_t pidWait;
    1689     InfoMsg(3, "%s - wait-child(%ld)\n", pszMsg, (long)pid);
     1716    InfoMsg(3, "%s - wait-child %ld\n", pszMsg, (long)pid);
    16901717
    16911718#ifdef __WIN__
    … …  
    18411868            FatalDie("failed to open/read '%s' in '%s': %s\n",
    18421869                     pWhich->pszCppName, pEntry->pszDir, strerror(errno));
    1843         InfoMsg(1, "failed to open/read '%s' in '%s': %s\n",
     1870        InfoMsg(2, "failed to open/read '%s' in '%s': %s\n",
    18441871                pWhich->pszCppName, pEntry->pszDir, strerror(errno));
    18451872        return -1;
    18461873    }
    18471874
    1848     InfoMsg(1, "precompiled file is %lu bytes long\n", (unsigned long)pWhich->cbCpp);
     1875    InfoMsg(3, "precompiled file is %lu bytes long\n", (unsigned long)pWhich->cbCpp);
    18491876    return 0;
    18501877}
    … …  
    18631890    kOCSumUpdate(&pEntry->New.SumHead, &Ctx, pEntry->New.pszCppMapping, pEntry->New.cbCpp);
    18641891    kOCSumFinalize(&pEntry->New.SumHead, &Ctx);
    1865     kOCSumInfo(&pEntry->New.SumHead, 1, "cpp (file)");
     1892    kOCSumInfo(&pEntry->New.SumHead, 4, "cpp (file)");
    18661893}
    18671894
    … …  
    19261953    pEntry->New.cbCpp = cbAlloc - cbLeft;
    19271954    kOCSumFinalize(&pEntry->New.SumHead, &Ctx);
    1928     kOCSumInfo(&pEntry->New.SumHead, 1, "cpp (pipe)");
     1955    kOCSumInfo(&pEntry->New.SumHead, 4, "cpp (pipe)");
    19291956}
    19301957
    … …  
    19611988            memcpy(psz + cch, "-old", sizeof("-old"));
    19621989
    1963             InfoMsg(1, "renaming '%s' to '%s' in '%s'\n", pEntry->Old.pszCppName, psz, pEntry->pszDir);
     1990            InfoMsg(3, "renaming '%s' to '%s' in '%s'\n", pEntry->Old.pszCppName, psz, pEntry->pszDir);
    19641991            UnlinkFileInDir(psz, pEntry->pszDir);
    19651992            if (RenameFileInDir(pEntry->Old.pszCppName, psz, pEntry->pszDir))
    … …  
    19732000         * Precompile it and calculate the checksum on the output.
    19742001         */
    1975         InfoMsg(1, "precompiling -> '%s'...\n", pEntry->New.pszCppName);
     2002        InfoMsg(3, "precompiling -> '%s'...\n", pEntry->New.pszCppName);
    19762003        kOCEntrySpawn(pEntry, papszArgvPreComp, cArgvPreComp, "precompile", NULL);
    19772004        kOCEntryReadCppOutput(pEntry, &pEntry->New, 0 /* fatal */);
    … …  
    21032130            &&  !pEntry->New.pszCppMapping)
    21042131            kOCEntryReadCppOutput(pEntry, &pEntry->New, 0 /* fatal */);
    2105         InfoMsg(1, "compiling -> '%s'...\n", pEntry->New.pszObjName);
     2132        InfoMsg(3, "compiling -> '%s'...\n", pEntry->New.pszObjName);
    21062133        kOCEntrySpawnConsumer(pEntry, (const char * const *)pEntry->New.papszArgvCompile, pEntry->New.cArgvCompile,
    21072134                              "compile", kOCEntryCompileProducer);
    … …  
    21112138        if (pEntry->fPipedPreComp)
    21122139            kOCEntryWriteCppOutput(pEntry, 1 /* free it */);
    2113         InfoMsg(1, "compiling -> '%s'...\n", pEntry->New.pszObjName);
     2140        InfoMsg(3, "compiling -> '%s'...\n", pEntry->New.pszObjName);
    21142141        kOCEntrySpawn(pEntry, (const char * const *)pEntry->New.papszArgvCompile, pEntry->New.cArgvCompile, "compile", NULL);
    21152142    }
    … …  
    21542181                     fdIn, (long)cbLeft, strerror(errno));
    21552182        }
    2156         InfoMsg(2, "precompiler|compile - read %d\n", cbRead);
     2183        InfoMsg(3, "precompiler|compile - read %d\n", cbRead);
    21572184
    21582185        /*
    … …  
    21882215        }
    21892216    }
    2190     InfoMsg(2, "precompiler|compile - done passhtru\n");
     2217    InfoMsg(3, "precompiler|compile - done passhtru\n");
    21912218
    21922219    close(fdIn);
    … …  
    21942221    pEntry->New.cbCpp = cbAlloc - cbLeft;
    21952222    kOCSumFinalize(&pEntry->New.SumHead, &Ctx);
    2196     kOCSumInfo(&pEntry->New.SumHead, 1, "cpp (tee)");
     2223    kOCSumInfo(&pEntry->New.SumHead, 4, "cpp (tee)");
    21972224
    21982225    /*
    … …  
    25912618    if (!kOCSumHasEqualInChain(&pEntry->Old.SumHead, &pEntry->New.SumHead))
    25922619    {
    2593         InfoMsg(1, "no checksum match - comparing output\n");
     2620        InfoMsg(2, "no checksum match - comparing output\n");
    25942621        if (!kOCEntryCompareOldAndNewOutput(pEntry))
    25952622            pEntry->fNeedCompiling = 1;
    … …  
    29863013    int fBad = 0;
    29873014
     3015    InfoMsg(4, "reading cache file...\n");
     3016
    29883017    /*
    29893018     * Rewind the file & stream, and associate a temporary buffer
    … …  
    30023031        ||  strcmp(g_szLine, "magic=kObjCache-v0.1.0\n"))
    30033032    {
    3004         InfoMsg(1, "bad cache file (magic)\n");
     3033        InfoMsg(2, "bad cache file (magic)\n");
    30053034        fBad = 1;
    30063035    }
    … …  
    30083037             ||  strncmp(g_szLine, "generation=", sizeof("generation=") - 1))
    30093038    {
    3010         InfoMsg(1, "bad cache file (generation)\n");
     3039        InfoMsg(2, "bad cache file (generation)\n");
    30113040        fBad = 1;
    30123041    }
    … …  
    30143043             && pCache->uGeneration == atol(&g_szLine[sizeof("generation=") - 1]))
    30153044    {
    3016         InfoMsg(1, "drop re-read unmodified cache file\n");
     3045        InfoMsg(3, "drop re-read unmodified cache file\n");
    30173046        fBad = 0;
    30183047    }
    … …  
    31553184                if ((fBad = pCache->paDigests[i].pszTarget == NULL))
    31563185                    break;
     3186                InfoMsg(4, "digest-%u: %s\n", i, pCache->paDigests[i].pszAbsPath
     3187                        ? pCache->paDigests[i].pszAbsPath : pCache->paDigests[i].pszRelPath);
    31573188            }
    31583189        if (fBad)
    3159             InfoMsg(1, "bad cache file (%s)\n", fBadBeforeMissing ? g_szLine : "missing stuff");
     3190            InfoMsg(2, "bad cache file (%s)\n", fBadBeforeMissing ? g_szLine : "missing stuff");
    31603191        else if (ferror(pCache->pFile))
    31613192        {
    3162             InfoMsg(1, "cache file read error\n");
     3193            InfoMsg(2, "cache file read error\n");
    31633194            fBad = 1;
    31643195        }
    … …  
    32633294#endif
    32643295        FatalDie("file truncation failed: %s\n", strerror(errno));
    3265     InfoMsg(1, "wrote '%s' in '%s', %d bytes\n", pCache->pszName, pCache->pszDir, cb);
     3296    InfoMsg(4, "wrote '%s' in '%s', %d bytes\n", pCache->pszName, pCache->pszDir, cb);
    32663297}
    32673298
    … …  
    33683399        kObjCacheRead(pCache);
    33693400    else
     3401    {
    33703402        pCache->fNewCache = 1;
     3403        InfoMsg(2, "the cache file is empty\n");
     3404    }
    33713405}
    33723406
    … …  
    34383472
    34393473            pCache->fDirty = 1;
     3474            InfoMsg(3, "removing entry '%s'; %d left.\n", kOCEntryAbsPath(pEntry), pCache->cDigests);
    34403475        }
    34413476    }
    … …  
    34823517     * Create a new digest.
    34833518     */
    3484     i = pCache->cDigests++;
    3485     kOCDigestInitFromEntry(&pCache->paDigests[i], pEntry);
     3519    kOCDigestInitFromEntry(&pCache->paDigests[pCache->cDigests], pEntry);
     3520    pCache->cDigests++;
     3521    InfoMsg(4, "Inserted digest #%u: %s\n", pCache->cDigests - 1, kOCEntryAbsPath(pEntry));
    34863522
    34873523    pCache->fDirty = 1;
    … …  
    35213557
    35223558            /* bad entry, purge it. */
     3559            InfoMsg(3, "removing bad digest '%s'\n", kOCDigestAbsPath(pDigest, pCache->pszDir));
    35233560            kOCDigestPurge(pDigest);
    35243561
    … …  
    37703807    pEntry = kOCEntryCreate(pszEntryFile);
    37713808    kOCEntryRead(pEntry);
     3809    kOCEntrySetCompileObjName(pEntry, pszObjName);
    37723810    kOCEntrySetCompileArgv(pEntry, papszArgvCompile, cArgvCompile);
    3773     kOCEntrySetCompileObjName(pEntry, pszObjName);
    37743811    kOCEntrySetTarget(pEntry, pszTarget);
    37753812    kOCEntrySetCppName(pEntry, pszPreCompName);
    … …  
    37883825         */
    37893826        kObjCacheUnlock(pCache);
     3827        InfoMsg(1, "doing full compile\n");
    37903828        kOCEntryPreCompileAndCompile(pEntry, papszArgvPreComp, cArgvPreComp);
    37913829        kObjCacheLock(pCache);
    … …  
    38113849            if (pUseEntry)
    38123850            {
     3851                InfoMsg(1, "using cache entry '%s'\n", kOCEntryAbsPath(pUseEntry));
    38133852                kOCEntryCopy(pEntry, pUseEntry);
    38143853                kOCEntryDestroy(pUseEntry);
    … …  
    38173856            {
    38183857                kObjCacheUnlock(pCache);
     3858                InfoMsg(1, "recompiling\n");
    38193859                kOCEntryCompileIt(pEntry);
    38203860                kObjCacheLock(pCache);
    … …  
    38223862        }
    38233863        else
     3864        {
     3865            InfoMsg(1, "no need to recompile\n");
    38243866            kObjCacheLock(pCache);
     3867        }
    38253868    }
    38263869
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette