Ignore:
Timestamp:
Mar 26, 2018, 10:25:56 PM (7 years ago)
Author:
bird
Message:

kmkbuiltin: funnel output thru output.c (usually via err.c).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kmk/kmkbuiltin/kSubmit.c

    r3173 r3192  
    293293 *
    294294 * @returns 0 on success, non-zero value on failure.
     295 * @param   pCtx                The command execution context.
    295296 * @param   pWorker             The worker structure.  Caller does the linking
    296297 *                              (as we might be reusing an existing worker
    … …  
    299300 * @param   cVerbosity          The verbosity level.
    300301 */
    301 static int kSubmitSpawnWorker(PWORKERINSTANCE pWorker, int cVerbosity)
     302static int kSubmitSpawnWorker(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, int cVerbosity)
    302303{
    303304#if defined(KBUILD_OS_WINDOWS) || defined(KBUILD_OS_OS2)
    … …  
    319320        pVarVolatile = lookup_variable(TUPLE("PATH_OUT_BASE"));
    320321        if (!pVarVolatile)
    321             warn("Neither PATH_OUT_BASE nor PATH_OUT was found.");
     322            warn(pCtx, "Neither PATH_OUT_BASE nor PATH_OUT was found.");
    322323    }
    323324
    … …  
    346347            if (   cchBinPath < sizeof(g_szArch)
    347348                || memcmp(&szExecutable[cchBinPath - sizeof(g_szArch) + 1], g_szArch, sizeof(g_szArch) - 1) != 0)
    348                 return errx(1, "KBUILD_BIN_PATH does not end with main architecture (%s) as expected: %s", pszBinPath, g_szArch);
     349                return errx(pCtx, 1, "KBUILD_BIN_PATH does not end with main architecture (%s) as expected: %s",
     350                            pszBinPath, g_szArch);
    349351            cchExectuable -= sizeof(g_szArch) - 1;
    350352            memcpy(&szExecutable[cchExectuable], g_szAltArch, sizeof(g_szAltArch) - 1);
    … …  
    417419                        pWorker->pid = GetProcessId(pWorker->hProcess);
    418420                        if (cVerbosity > 0)
    419                             fprintf(stderr, "kSubmit: created %d bit worker %d\n", pWorker->cBits, pWorker->pid);
     421                            warnx(pCtx, "created %d bit worker %d\n", pWorker->cBits, pWorker->pid);
    420422                        return 0;
    421423                    }
    422                     err(1, "_spawnve(,%s,,)", szExecutable);
     424                    err(pCtx, 1, "_spawnve(,%s,,)", szExecutable);
    423425                    CloseHandle(pWorker->OverlappedRead.hEvent);
    424426                    pWorker->OverlappedRead.hEvent = INVALID_HANDLE_VALUE;
    425427                }
    426428                else
    427                     errx(1, "CreateEventW failed: %u", GetLastError());
     429                    errx(pCtx, 1, "CreateEventW failed: %u", GetLastError());
    428430                CloseHandle(pWorker->hPipe);
    429431                pWorker->hPipe = INVALID_HANDLE_VALUE;
    430432            }
    431433            else
    432                 errx(1, "Opening named pipe failed: %u", GetLastError());
     434                errx(pCtx, 1, "Opening named pipe failed: %u", GetLastError());
    433435            CloseHandle(hWorkerPipe);
    434436        }
    435437        else
    436             errx(1, "CreateNamedPipeW failed: %u", GetLastError());
     438            errx(pCtx, 1, "CreateNamedPipeW failed: %u", GetLastError());
    437439
    438440#else
    … …  
    441443         */
    442444        if (socketpair(AF_LOCAL, SOCK_STREAM, 0, aiPair) == 0)
    443         {
    444445            pWorker->fdSocket = aiPair[1];
    445         }
    446446        else
    447             err(1, "socketpair");
     447            err(pCtx, 1, "socketpair");
    448448#endif
    449449    }
    450450    else
    451         errx(1, "KBUILD_BIN_PATH is too long");
     451        errx(pCtx, 1, "KBUILD_BIN_PATH is too long");
    452452    return -1;
    453453}
    … …  
    458458 *
    459459 * @returns Pointer to the selected worker instance.  NULL on error.
     460 * @param   pCtx                The command execution context.
    460461 * @param   pWorker             The idle worker instance to respawn.
    461462 *                              On failure this will be freed!
    462463 * @param   cBitsWorker         The worker bitness - 64 or 32.
    463464 */
    464 static int kSubmitRespawnWorker(PWORKERINSTANCE pWorker, int cVerbosity)
     465static int kSubmitRespawnWorker(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, int cVerbosity)
    465466{
    466467    /*
    … …  
    475476    {
    476477        if (!CloseHandle(pWorker->hPipe))
    477             warnx("CloseHandle(pWorker->hPipe): %u", GetLastError());
     478            warnx(pCtx, "CloseHandle(pWorker->hPipe): %u", GetLastError());
    478479        pWorker->hPipe = INVALID_HANDLE_VALUE;
    479480    }
    480481
    481482    if (!CloseHandle(pWorker->OverlappedRead.hEvent))
    482         warnx("CloseHandle(pWorker->OverlappedRead.hEvent): %u", GetLastError());
     483        warnx(pCtx, "CloseHandle(pWorker->OverlappedRead.hEvent): %u", GetLastError());
    483484    pWorker->OverlappedRead.hEvent = INVALID_HANDLE_VALUE;
    484485
    … …  
    491492        rcWait = WaitForSingleObject(pWorker->hProcess, 100);
    492493        if (rcWait != WAIT_OBJECT_0)
    493             warnx("WaitForSingleObject returns %u (and TerminateProcess %d)", rcWait, fRc);
     494            warnx(pCtx, "WaitForSingleObject returns %u (and TerminateProcess %d)", rcWait, fRc);
    494495    }
    495496
    496497    if (!CloseHandle(pWorker->hProcess))
    497         warnx("CloseHandle(pWorker->hProcess): %u", GetLastError());
     498        warnx(pCtx, "CloseHandle(pWorker->hProcess): %u", GetLastError());
    498499    pWorker->hProcess = INVALID_HANDLE_VALUE;
    499500
    … …  
    505506    {
    506507        if (close(pWorker->fdSocket) != 0)
    507             warn("close(pWorker->fdSocket)");
     508            warn(pCtx, "close(pWorker->fdSocket)");
    508509        pWorker->fdSocket = -1;
    509510    }
    … …  
    512513    pidWait = waitpid(pWorker->pid, &rc, 0);
    513514    if (pidWait != pWorker->pid)
    514         warn("waitpid(pWorker->pid,,0)");
     515        warn(pCtx, "waitpid(pWorker->pid,,0)");
    515516#endif
    516517
    … …  
    523524     * Respawn it.
    524525     */
    525     if (kSubmitSpawnWorker(pWorker, cVerbosity) == 0)
     526    if (kSubmitSpawnWorker(pCtx, pWorker, cVerbosity) == 0)
    526527    {
    527528        /*
    … …  
    546547 * @param   cBitsWorker         The worker bitness - 64 or 32.
    547548 */
    548 static PWORKERINSTANCE kSubmitSelectWorkSpawnNewIfNecessary(unsigned cBitsWorker, int cVerbosity)
     549static PWORKERINSTANCE kSubmitSelectWorkSpawnNewIfNecessary(PKMKBUILTINCTX pCtx, unsigned cBitsWorker, int cVerbosity)
    549550{
    550551    /*
    … …  
    564565    pWorker = (PWORKERINSTANCE)xcalloc(sizeof(*pWorker));
    565566    pWorker->cBits = cBitsWorker;
    566     if (kSubmitSpawnWorker(pWorker, cVerbosity) == 0)
     567    if (kSubmitSpawnWorker(pCtx, pWorker, cVerbosity) == 0)
    567568    {
    568569        /*
    … …  
    715716 * @returns 0 on success, non-zero on failure.
    716717 *
     718 * @param   pCtx                The command execution context.
    717719 * @param   pWorker             The work to send the request to.  The worker is
    718720 *                              on the idle list.
    … …  
    722724 * @param   cVerbosity          The verbosity level.
    723725 */
    724 static int kSubmitSendJobMessage(PWORKERINSTANCE pWorker, void const *pvMsg, uint32_t cbMsg, int fNoRespawning, int cVerbosity)
     726static int kSubmitSendJobMessage(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, void const *pvMsg, uint32_t cbMsg,
     727                                 int fNoRespawning, int cVerbosity)
    725728{
    726729    int cRetries;
    … …  
    738741        {
    739742            if (cVerbosity > 0)
    740                 fprintf(stderr,  "kSubmit: Respawning worker (#1)...\n");
    741             if (kSubmitRespawnWorker(pWorker, cVerbosity) != 0)
     743                warnx(pCtx, "Respawning worker (#1)...\n");
     744            if (kSubmitRespawnWorker(pCtx, pWorker, cVerbosity) != 0)
    742745                return 2;
    743746        }
    … …  
    772775                && dwErr != ERROR_NO_DATA)
    773776            || cRetries <= 0)
    774             return errx(1, "Error writing to worker: %u", dwErr);
     777            return errx(pCtx, 1, "Error writing to worker: %u", dwErr);
    775778#else
    776779        ssize_t cbWritten
    … …  
    788791               && errno != ECONNRESET))
    789792            || cRetries <= 0)
    790             return err(1, "Error writing to worker");
     793            return err(pCtx, 1, "Error writing to worker");
    791794# error "later"
    792795#endif
    … …  
    796799         */
    797800        if (cVerbosity > 0)
    798             fprintf(stderr,  "kSubmit: Respawning worker (#2)...\n");
    799         if (kSubmitRespawnWorker(pWorker, cVerbosity) != 0)
     801            warnx(pCtx, "Respawning worker (#2)...\n");
     802        if (kSubmitRespawnWorker(pCtx, pWorker, cVerbosity) != 0)
    800803            return 2;
    801804    }
    … …  
    814817 * which the process can terminate without us having to actively wait for it.
    815818 *
     819 * @param   pCtx                The command execution context.
    816820 * @param   pWorker             The worker instance.
    817821 */
    818 static void kSubmitCloseConnectOnExitingWorker(PWORKERINSTANCE pWorker)
     822static void kSubmitCloseConnectOnExitingWorker(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker)
    819823{
    820824#ifdef KBUILD_OS_WINDOWS
    821825    if (!CloseHandle(pWorker->hPipe))
    822         warnx("CloseHandle(pWorker->hPipe): %u", GetLastError());
     826        warnx(pCtx, "CloseHandle(pWorker->hPipe): %u", GetLastError());
    823827    pWorker->hPipe = INVALID_HANDLE_VALUE;
    824828#else
    825829    if (close(pWorker->fdSocket) != 0)
    826         warn("close(pWorker->fdSocket)");
     830        warn(pCtx, "close(pWorker->fdSocket)");
    827831    pWorker->fdSocket = -1;
    828832#endif
    … …  
    836840 *
    837841 * @returns Exit code.
     842 * @param   pCtx                The command execution context.
    838843 * @param   pWorker             The worker instance.
    839844 * @param   dwErr               The error code.
    840845 * @param   pszWhere            Where it failed.
    841846 */
    842 static int kSubmitWinReadFailed(PWORKERINSTANCE pWorker, DWORD dwErr, const char *pszWhere)
     847static int kSubmitWinReadFailed(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, DWORD dwErr, const char *pszWhere)
    843848{
    844849    DWORD dwExitCode;
    845850
    846851    if (pWorker->cbResultRead == 0)
    847         errx(1, "%s/ReadFile failed: %u", pszWhere, dwErr);
     852        errx(pCtx, 1, "%s/ReadFile failed: %u", pszWhere, dwErr);
    848853    else
    849         errx(1, "%s/ReadFile failed: %u (read %u bytes)", pszWhere, dwErr, pWorker->cbResultRead);
     854        errx(pCtx, 1, "%s/ReadFile failed: %u (read %u bytes)", pszWhere, dwErr, pWorker->cbResultRead);
    850855    assert(dwErr != 0);
    851856
    … …  
    870875 * @returns 0 if we got the whole result, -1 if I/O is pending, and windows last
    871876 *          error on ReadFile failure.
     877 * @param   pCtx                The command execution context.
    872878 * @param   pWorker             The worker instance.
    873879 */
    874 static int kSubmitReadMoreResultWin(PWORKERINSTANCE pWorker, const char *pszWhere)
     880static int kSubmitReadMoreResultWin(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, const char *pszWhere)
    875881{
    876882    /*
    … …  
    895901            if (dwErr == ERROR_IO_PENDING)
    896902                return -1;
    897             return kSubmitWinReadFailed(pWorker, dwErr, pszWhere);
     903            return kSubmitWinReadFailed(pCtx, pWorker, dwErr, pszWhere);
    898904        }
    899905
    … …  
    913919 *
    914920 * @returns Exit code.
     921 * @param   pCtx                The command execution context.
    915922 * @param   pWorker             The worker instance to mark as active.
    916923 * @param   cVerbosity          The verbosity level.
    … …  
    920927 *                              and we've returned the exit code of the job.
    921928 */
    922 static int kSubmitMarkActive(PWORKERINSTANCE pWorker, int cVerbosity, struct child *pChild, pid_t *pPidSpawned)
     929static int kSubmitMarkActive(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, int cVerbosity, struct child *pChild, pid_t *pPidSpawned)
    923930{
    924931#ifdef KBUILD_OS_WINDOWS
    … …  
    934941     */
    935942l_again:
    936     rc = kSubmitReadMoreResultWin(pWorker, "kSubmitMarkActive");
     943    rc = kSubmitReadMoreResultWin(pCtx, pWorker, "kSubmitMarkActive");
    937944    if (rc == -1)
    938945    {
    … …  
    943950        {
    944951            /* We need to do the waiting here because sub_proc.c has too much to do. */
    945             warnx("Too many processes for sub_proc.c to handle!");
     952            warnx(pCtx, "Too many processes for sub_proc.c to handle!");
    946953            WaitForSingleObject(pWorker->OverlappedRead.hEvent, INFINITE);
    947954            goto l_again;
    … …  
    953960        {
    954961            /* We need to do the waiting here because sub_proc.c has too much to do. */
    955             warnx("MkWinChildCreateSubmit failed!");
     962            warnx(pCtx, "MkWinChildCreateSubmit failed!");
    956963            WaitForSingleObject(pWorker->OverlappedRead.hEvent, INFINITE);
    957964            goto l_again;
    … …  
    963970        assert(rc == 0 || pWorker->Result.s.rcExit != 0);
    964971        if (pWorker->Result.s.bWorkerExiting)
    965             kSubmitCloseConnectOnExitingWorker(pWorker);
     972            kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
    966973        *pPidSpawned = 0;
    967974        return pWorker->Result.s.rcExit;
    … …  
    9981005{
    9991006    PWORKERINSTANCE pWorker = (PWORKERINSTANCE)pvUser;
     1007    KMKBUILTINCTX   FakeCtx = { "kSubmit/GetResult", NULL };
     1008    PKMKBUILTINCTX  pCtx = &FakeCtx;
    10001009
    10011010    /*
    … …  
    10121021        while (pWorker->cbResultRead < sizeof(pWorker->Result))
    10131022        {
    1014             int rc = kSubmitReadMoreResultWin(pWorker, "kSubmitSubProcGetResult/more");
     1023            int rc = kSubmitReadMoreResultWin(pCtx, pWorker, "kSubmitSubProcGetResult/more");
    10151024            if (rc == -1)
    10161025                return -1;
    … …  
    10221031    {
    10231032        DWORD dwErr = GetLastError();
    1024         kSubmitWinReadFailed(pWorker, dwErr, "kSubmitSubProcGetResult/result");
     1033        kSubmitWinReadFailed(pCtx, pWorker, dwErr, "kSubmitSubProcGetResult/result");
    10251034    }
    10261035
    … …  
    10391048    }
    10401049    if (pWorker->Result.s.bWorkerExiting)
    1041         kSubmitCloseConnectOnExitingWorker(pWorker);
     1050        kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
    10421051
    10431052    return 0;
    … …  
    10741083    DWORD           msStartTick;
    10751084    DWORD           cKillRaids = 0;
     1085    KMKBUILTINCTX   FakeCtx = { "kSubmit/atexit", NULL };
     1086    PKMKBUILTINCTX  pCtx = &FakeCtx;
    10761087
    10771088    /*
    … …  
    10791090     */
    10801091    for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
    1081         kSubmitCloseConnectOnExitingWorker(pWorker);
     1092        kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
    10821093    for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
    1083         kSubmitCloseConnectOnExitingWorker(pWorker);
     1094        kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
    10841095
    10851096    /*
    … …  
    11571168                if (cKillRaids == 1 && getenv("KMK_KSUBMIT_NO_KILL") == NULL)
    11581169                {
    1159                     fprintf(stderr, "kmk/kSubmit: Killing %u lingering worker processe(s)!\n", cHandles);
     1170                    warnx(pCtx, "Killing %u lingering worker processe(s)!\n", cHandles);
    11601171                    for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
    11611172                        if (pWorker->hProcess != INVALID_HANDLE_VALUE)
    … …  
    11671178                else
    11681179                {
    1169                     fprintf(stderr, "kmk/kSubmit: Giving up on the last %u worker processe(s). :-(\n", cHandles);
     1180                    warnx(pCtx, "Giving up on the last %u worker processe(s). :-(\n", cHandles);
    11701181                    return;
    11711182                }
    … …  
    11761187                   bad ones as well as completed ones. */
    11771188                size_t idx;
    1178                 fprintf(stderr, "kmk/kSubmit: WaitForMultipleObjects unexpectedly returned %#u (err=%u)\n",
    1179                         dwWait, GetLastError());
     1189                warnx(pCtx, "WaitForMultipleObjects unexpectedly returned %#u (err=%u)\n",
     1190                      dwWait, GetLastError());
    11801191                for (idx = 0; idx < cHandles; idx++)
    11811192                {
    … …  
    11941205
    11951206
    1196 static int usage(FILE *pOut,  const char *argv0)
    1197 {
    1198     fprintf(pOut,
    1199             "usage: %s [-Z|--zap-env] [-E|--set <var=val>] [-U|--unset <var=val>]\n"
    1200             "           [-A|--append <var=val>] [-D|--prepend <var=val>]\n"
    1201             "           [-C|--chdir <dir>] [--wcc-brain-damage] [--no-pch-caching]\n"
    1202             "           [-3|--32-bit] [-6|--64-bit] [-v]\n"
    1203             "           [-P|--post-cmd <cmd> [args]] -- <program> [args]\n"
    1204             "   or: %s --help\n"
    1205             "   or: %s --version\n"
    1206             "\n"
    1207             "Options:\n"
    1208             "  -Z, --zap-env, -i, --ignore-environment\n"
    1209             "    Zaps the environment. Position dependent.\n"
    1210             "  -E, --set <var>=[value]\n"
    1211             "    Sets an enviornment variable putenv fashion. Position dependent.\n"
    1212             "  -U, --unset <var>\n"
    1213             "    Removes an environment variable. Position dependent.\n"
    1214             "  -A, --append <var>=<value>\n"
    1215             "    Appends the given value to the environment variable.\n"
    1216             "  -D,--prepend <var>=<value>\n"
    1217             "    Prepends the given value to the environment variable.\n"
    1218             "  -C, --chdir <dir>\n"
    1219             "    Specifies the current directory for the program.  Relative paths\n"
    1220             "    are relative to the previous -C option.  Default is getcwd value.\n"
    1221             "  -3, --32-bit\n"
    1222             "    Selects a 32-bit kWorker process. Default: kmk bit count\n"
    1223             "  -6, --64-bit\n"
    1224             "    Selects a 64-bit kWorker process. Default: kmk bit count\n"
    1225             "  --wcc-brain-damage\n"
    1226             "    Works around wcc and wcc386 (Open Watcom) not following normal\n"
    1227             "    quoting conventions on Windows, OS/2, and DOS.\n"
    1228             "  --no-pch-caching\n"
    1229             "    Do not cache precompiled header files because they're being created.\n"
    1230             "  -v,--verbose\n"
    1231             "    More verbose execution.\n"
    1232             "  -P|--post-cmd <cmd> ...\n"
    1233             "    For running a built-in command on the output, specifying the command\n"
    1234             "    and all it's parameters.  Currently supported commands:\n"
    1235             "        kDepObj\n"
    1236             "  -V,--version\n"
    1237             "    Show the version number.\n"
    1238             "  -h,--help\n"
    1239             "    Show this usage information.\n"
    1240             "\n"
    1241             ,
    1242             argv0, argv0, argv0);
     1207static int kmk_builtin_kSubmit_usage(PKMKBUILTINCTX pCtx, int fIsErr)
     1208{
     1209    kmk_builtin_ctx_printf(pCtx, fIsErr,
     1210                           "usage: %s [-Z|--zap-env] [-E|--set <var=val>] [-U|--unset <var=val>]\n"
     1211                           "           [-A|--append <var=val>] [-D|--prepend <var=val>]\n"
     1212                           "           [-C|--chdir <dir>] [--wcc-brain-damage] [--no-pch-caching]\n"
     1213                           "           [-3|--32-bit] [-6|--64-bit] [-v]\n"
     1214                           "           [-P|--post-cmd <cmd> [args]] -- <program> [args]\n"
     1215                           "   or: %s --help\n"
     1216                           "   or: %s --version\n"
     1217                           "\n"
     1218                           "Options:\n"
     1219                           "  -Z, --zap-env, -i, --ignore-environment\n"
     1220                           "    Zaps the environment. Position dependent.\n"
     1221                           "  -E, --set <var>=[value]\n"
     1222                           "    Sets an enviornment variable putenv fashion. Position dependent.\n"
     1223                           "  -U, --unset <var>\n"
     1224                           "    Removes an environment variable. Position dependent.\n"
     1225                           "  -A, --append <var>=<value>\n"
     1226                           "    Appends the given value to the environment variable.\n"
     1227                           "  -D,--prepend <var>=<value>\n"
     1228                           "    Prepends the given value to the environment variable.\n"
     1229                           "  -C, --chdir <dir>\n"
     1230                           "    Specifies the current directory for the program.  Relative paths\n"
     1231                           "    are relative to the previous -C option.  Default is getcwd value.\n"
     1232                           "  -3, --32-bit\n"
     1233                           "    Selects a 32-bit kWorker process. Default: kmk bit count\n"
     1234                           "  -6, --64-bit\n"
     1235                           "    Selects a 64-bit kWorker process. Default: kmk bit count\n"
     1236                           "  --wcc-brain-damage\n"
     1237                           "    Works around wcc and wcc386 (Open Watcom) not following normal\n"
     1238                           "    quoting conventions on Windows, OS/2, and DOS.\n"
     1239                           "  --no-pch-caching\n"
     1240                           "    Do not cache precompiled header files because they're being created.\n"
     1241                           "  -v,--verbose\n"
     1242                           "    More verbose execution.\n"
     1243                           "  -P|--post-cmd <cmd> ...\n"
     1244                           "    For running a built-in command on the output, specifying the command\n"
     1245                           "    and all it's parameters.  Currently supported commands:\n"
     1246                           "        kDepObj\n"
     1247                           "  -V,--version\n"
     1248                           "    Show the version number.\n"
     1249                           "  -h,--help\n"
     1250                           "    Show this usage information.\n"
     1251                           "\n"
     1252                           ,
     1253                           pCtx->pszProgName, pCtx->pszProgName, pCtx->pszProgName);
    12431254    return 2;
    12441255}
    12451256
    12461257
    1247 int kmk_builtin_kSubmit(int argc, char **argv, char **envp, struct child *pChild, pid_t *pPidSpawned)
     1258int kmk_builtin_kSubmit(int argc, char **argv, char **envp, PKMKBUILTINCTX pCtx, struct child *pChild, pid_t *pPidSpawned)
    12481259{
    12491260    int             rcExit = 0;
    … …  
    12621273    PATH_VAR(szCwd);
    12631274
    1264     g_progname = argv[0];
    1265 
    12661275    /*
    12671276     * Create default program environment.
    … …  
    12731282    { /* likely */ }
    12741283    else
    1275         return err(1, "getcwd_fs failed\n");
     1284        return err(pCtx, 1, "getcwd_fs failed\n");
    12761285
    12771286    /* The environment starts out in read-only mode and will be duplicated if modified. */
    … …  
    12981307                else
    12991308                {
    1300                     errx(1, "Incomplete option: '-'");
    1301                     return usage(stderr, argv[0]);
     1309                    errx(pCtx, 1, "Incomplete option: '-'");
     1310                    return kmk_builtin_kSubmit_usage(pCtx, 1);
    13021311                }
    13031312            }
    … …  
    13541363                else
    13551364                {
    1356                     errx(2, "Unknown option: '%s'", pszArg - 2);
    1357                     return usage(stderr, argv[0]);
     1365                    errx(pCtx, 2, "Unknown option: '%s'", pszArg - 2);
     1366                    return kmk_builtin_kSubmit_usage(pCtx, 1);
    13581367                }
    13591368                pszArg = "";
    … …  
    13781387                        else
    13791388                        {
    1380                             errx(1, "Option -%c requires a value!", chOpt);
    1381                             return usage(stderr, argv[0]);
     1389                            errx(pCtx, 1, "Option -%c requires a value!", chOpt);
     1390                            return kmk_builtin_kSubmit_usage(pCtx, 1);
    13821391                        }
    13831392                        break;
    … …  
    13881397                    case 'Z':
    13891398                    case 'i': /* GNU env compatibility. */
    1390                         rcExit = kBuiltinOptEnvZap(&papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity);
     1399                        rcExit = kBuiltinOptEnvZap(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity);
    13911400                        if (rcExit == 0)
    13921401                            break;
    … …  
    13941403
    13951404                    case 'E':
    1396                         rcExit = kBuiltinOptEnvSet(&papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
     1405                        rcExit = kBuiltinOptEnvSet(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
    13971406                        if (rcExit == 0)
    13981407                            break;
    … …  
    14001409
    14011410                    case 'A':
    1402                         rcExit = kBuiltinOptEnvAppend(&papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
     1411                        rcExit = kBuiltinOptEnvAppend(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
    14031412                        if (rcExit == 0)
    14041413                            break;
    … …  
    14061415
    14071416                    case 'D':
    1408                         rcExit = kBuiltinOptEnvPrepend(&papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
     1417                        rcExit = kBuiltinOptEnvPrepend(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
    14091418                        if (rcExit == 0)
    14101419                            break;
    … …  
    14121421
    14131422                    case 'U':
    1414                         rcExit = kBuiltinOptEnvUnset(&papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
     1423                        rcExit = kBuiltinOptEnvUnset(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
    14151424                        if (rcExit == 0)
    14161425                            break;
    … …  
    14181427
    14191428                    case 'C':
    1420                         rcExit = kBuiltinOptChDir(szCwd, cbCwdBuf, pszValue);
     1429                        rcExit = kBuiltinOptChDir(pCtx, szCwd, cbCwdBuf, pszValue);
    14211430                        if (rcExit == 0)
    14221431                            break;
    … …  
    14251434                    case 'P':
    14261435                        if (cPostCmdArgs > 0)
    1427                             return errx(1, "The -P option can only be used once!");
     1436                            return errx(pCtx, 1, "The -P option can only be used once!");
    14281437                        if (*pszArg != '\0')
    1429                             return errx(1, "The cmd part of the -P needs to be a separate argument!");
     1438                            return errx(pCtx, 1, "The cmd part of the -P needs to be a separate argument!");
    14301439                        iPostCmd = ++iArg;
    14311440                        if (iArg >= argc)
    1432                             return errx(1, "The -P option requires a command following it!");
     1441                            return errx(pCtx, 1, "The -P option requires a command following it!");
    14331442                        while (iArg < argc && strcmp(argv[iArg], "--") != 0)
    14341443                            iArg++;
    … …  
    14541463
    14551464                    case 'h':
    1456                         usage(stdout, argv[0]);
     1465                        kmk_builtin_kSubmit_usage(pCtx, 0);
    14571466                        kBuiltinOptEnvCleanup(&papszEnvVars, cEnvVars, &cAllocatedEnvVars);
    14581467                        return 0;
    … …  
    14661475        else
    14671476        {
    1468             errx(1, "Unknown argument: '%s'", pszArg);
    1469             return usage(stderr, argv[0]);
     1477            errx(pCtx, 1, "Unknown argument: '%s'", pszArg);
     1478            return kmk_builtin_kSubmit_usage(pCtx, 1);
    14701479        }
    14711480    }
    … …  
    14801489                                                           fWatcomBrainDamage, fNoPchCaching,
    14811490                                                           &argv[iPostCmd], cPostCmdArgs, &cbMsg);
    1482         PWORKERINSTANCE pWorker = kSubmitSelectWorkSpawnNewIfNecessary(cBitsWorker, cVerbosity);
     1491        PWORKERINSTANCE pWorker = kSubmitSelectWorkSpawnNewIfNecessary(pCtx, cBitsWorker, cVerbosity);
    14831492        if (pWorker)
    14841493        {
    … …  
    14861495                pszExecutable = argv[iArg];
    14871496
    1488             rcExit = kSubmitSendJobMessage(pWorker, pvMsg, cbMsg, 0 /*fNoRespawning*/, cVerbosity);
     1497            rcExit = kSubmitSendJobMessage(pCtx, pWorker, pvMsg, cbMsg, 0 /*fNoRespawning*/, cVerbosity);
    14891498            if (rcExit == 0)
    1490                 rcExit = kSubmitMarkActive(pWorker, cVerbosity, pChild, pPidSpawned);
     1499                rcExit = kSubmitMarkActive(pCtx, pWorker, cVerbosity, pChild, pPidSpawned);
    14911500
    14921501            if (!g_fAtExitRegistered)
    … …  
    15001509    else
    15011510    {
    1502         errx(1, "Nothing to executed!");
    1503         rcExit = usage(stderr, argv[0]);
     1511        errx(pCtx, 1, "Nothing to executed!");
     1512        rcExit = kmk_builtin_kSubmit_usage(pCtx, 1);
    15041513    }
    15051514
Note: See TracChangeset for help on using the changeset viewer.