VirtualBox

Changeset 2894 in kBuild


Ignore:
Timestamp:
Sep 8, 2016 1:27:56 PM (8 years ago)
Author:
bird
Message:

Included kDepObj in kWorker as a post execution option.

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kWorker/Makefile.kmk

    r2878 r2894  
    3333kWorker_DEFS.debug = K_STRICT
    3434kWorker_DEFS.release = NASSERT
    35 kWorker_SOURCES = kWorker.c
     35kWorker_SOURCES = \
     36        kWorker.c \
     37       ../kmk/kmkbuiltin/kDepObj.c
     38kWorker_INCS = \
     39        ../kmk/ \
     40        ../kmk/kmkbuiltin
    3641kWorker_LIBS = \
    3742        $(kStuff_1_TARGET) \
    … …  
    5661        crc32.c \
    5762        md5.c \
    58        kbuild_version.c
     63       kbuild_version.c \
     64       kDep.c
    5965kWorkerLib_SOURCES.win = \
    6066        nt_fullpath.c \
     67        nt_fullpath_cached.c \
    6168        quoted_spawn.c \
    6269       nt/nthlpcore.c \

  • trunk/src/kWorker/kWorker.c

    r2892 r2894  
    5353#include "quote_argv.h"
    5454#include "md5.h"
     55
     56#include "../kmk/kmkbuiltin.h"
    5557
    5658
    … …  
    68946896
    68956897/**
     6898 * Does the post command part of a job (optional).
     6899 *
     6900 * @returns The exit code of the job.
     6901 * @param   cPostCmdArgs        Number of post command arguments (includes cmd).
     6902 * @param   papszPostCmdArgs    The post command and its argument.
     6903 */
     6904static int kSubmitHandleJobPostCmd(KU32 cPostCmdArgs, const char **papszPostCmdArgs)
     6905{
     6906    const char *pszCmd = papszPostCmdArgs[0];
     6907
     6908    /* Allow the kmk builtin prefix. */
     6909    static const char s_szKmkBuiltinPrefix[] = "kmk_builtin_";
     6910    if (kHlpStrNComp(pszCmd, s_szKmkBuiltinPrefix, sizeof(s_szKmkBuiltinPrefix) - 1) == 0)
     6911        pszCmd += sizeof(s_szKmkBuiltinPrefix) - 1;
     6912
     6913    /* Command switch. */
     6914    if (kHlpStrComp(pszCmd, "kDepObj") == 0)
     6915        return kmk_builtin_kDepObj(cPostCmdArgs, (char **)papszPostCmdArgs, NULL);
     6916
     6917    return kwErrPrintfRc(42 + 5 , "Unknown post command: '%s'\n", pszCmd);
     6918}
     6919
     6920
     6921/**
    68966922 * Part 2 of the "JOB" command handler.
    68976923 *
    68986924 * @returns The exit code of the job.
    6899  * @param   pszExecutable   The executable to execute.
    6900  * @param   pszCwd          The current working directory of the job.
    6901  * @param   cArgs           The number of arguments.
    6902  * @param   papszArgs       The argument vector.
     6925 * @param   pszExecutable       The executable to execute.
     6926 * @param   pszCwd              The current working directory of the job.
     6927 * @param   cArgs               The number of arguments.
     6928 * @param   papszArgs           The argument vector.
    69036929 * @param   fWatcomBrainDamange Whether to apply watcom rules while quoting.
    6904  * @param   cEnvVars        The number of environment variables.
    6905  * @param   papszEnvVars    The enviornment vector.
     6930 * @param   cEnvVars            The number of environment variables.
     6931 * @param   papszEnvVars        The enviornment vector.
     6932 * @param   cPostCmdArgs        Number of post command arguments (includes cmd).
     6933 * @param   papszPostCmdArgs    The post command and its argument.
    69066934 */
    69076935static int kSubmitHandleJobUnpacked(const char *pszExecutable, const char *pszCwd,
    69086936                                    KU32 cArgs, const char **papszArgs, KBOOL fWatcomBrainDamange,
    6909                                     KU32 cEnvVars, const char **papszEnvVars)
     6937                                    KU32 cEnvVars, const char **papszEnvVars,
     6938                                    KU32 cPostCmdArgs, const char **papszPostCmdArgs)
    69106939{
    69116940    int rcExit;
    … …  
    69727001                break;
    69737002        }
     7003
     7004        /*
     7005         * Do the post command, if present.
     7006         */
     7007        if (cPostCmdArgs && rcExit == 0)
     7008            rcExit = kSubmitHandleJobPostCmd(cPostCmdArgs, papszPostCmdArgs);
    69747009    }
    69757010    else
    … …  
    70637098                            if (papszEnvVars)
    70647099                            {
    7065                                 KU32 i;
    70667100                                for (i = 0; i < cEnvVars; i++)
    70677101                                {
    … …  
    70787112                                }
    70797113                                papszEnvVars[cEnvVars] = 0;
     7114
     7115                                /* Flags (currently just watcom argument brain damanage). */
    70807116                                if (cbMsg >= sizeof(KU8))
    70817117                                {
    70827118                                    KBOOL fWatcomBrainDamange = *pszMsg++;
    70837119                                    cbMsg--;
    7084                                     if (cbMsg == 0)
     7120
     7121                                    /* Post command argument count (can be zero). */
     7122                                    if (cbMsg >= sizeof(KU32))
    70857123                                    {
    7086                                         /*
    7087                                          * The next step.
    7088                                          */
    7089                                         rcExit = kSubmitHandleJobUnpacked(pszExecutable, pszCwd,
    7090                                                                           cArgs, papszArgs, fWatcomBrainDamange,
    7091                                                                           cEnvVars, papszEnvVars);
     7124                                        KU32 cPostCmdArgs;
     7125                                        kHlpMemCopy(&cPostCmdArgs, pszMsg, sizeof(cPostCmdArgs));
     7126                                        pszMsg += sizeof(cPostCmdArgs);
     7127                                        cbMsg  -= sizeof(cPostCmdArgs);
     7128
     7129                                        if (cPostCmdArgs >= 0 && cPostCmdArgs < 32)
     7130                                        {
     7131                                            char const *apszPostCmdArgs[32+1];
     7132                                            for (i = 0; i < cPostCmdArgs; i++)
     7133                                            {
     7134                                                apszPostCmdArgs[i] = pszMsg;
     7135                                                cbTmp = kHlpStrLen(pszMsg) + 1;
     7136                                                pszMsg += cbTmp;
     7137                                                if (   cbTmp < cbMsg
     7138                                                    || (cbTmp == cbMsg && i + 1 == cPostCmdArgs))
     7139                                                    cbMsg -= cbTmp;
     7140                                                else
     7141                                                {
     7142                                                    cbMsg = KSIZE_MAX;
     7143                                                    break;
     7144                                                }
     7145                                            }
     7146                                            if (cbMsg == 0)
     7147                                            {
     7148                                                apszPostCmdArgs[cPostCmdArgs] = NULL;
     7149
     7150                                                /*
     7151                                                 * The next step.
     7152                                                 */
     7153                                                rcExit = kSubmitHandleJobUnpacked(pszExecutable, pszCwd,
     7154                                                                                  cArgs, papszArgs, fWatcomBrainDamange,
     7155                                                                                  cEnvVars, papszEnvVars,
     7156                                                                                  cPostCmdArgs, apszPostCmdArgs);
     7157                                            }
     7158                                            else if (cbMsg == KSIZE_MAX)
     7159                                                kwErrPrintf("Detected bogus message unpacking post command and its arguments!\n");
     7160                                            else
     7161                                                kwErrPrintf("Message has %u bytes unknown trailing bytes\n", cbMsg);
     7162                                        }
     7163                                        else
     7164                                            kwErrPrintf("Bogus post command argument count: %u %#x\n", cPostCmdArgs, cPostCmdArgs);
    70927165                                    }
    70937166                                    else
    7094                                         kwErrPrintf("Message has %u bytes unknown trailing bytes\n", cbMsg);
     7167                                        kwErrPrintf("Detected bogus message looking for the post command argument count!\n");
    70957168                                }
    70967169                                else
    … …  
    72817354        rcExit = kSubmitHandleJobUnpacked(argv[i], pszCwd,
    72827355                                          argc - i, &argv[i], fWatcomBrainDamange,
    7283                                           cEnvVars, environ);
     7356                                          cEnvVars, environ,
     7357                                          0, NULL);
    72847358        KW_LOG(("rcExit=%d\n", rcExit));
    72857359        kwSandboxCleanupLate(&g_Sandbox);

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

    r2856 r2894  
    2828*******************************************************************************/
    2929#define MSCFAKES_NO_WINDOWS_H
    30 #include "config.h"
    3130#include <stdio.h>
    3231#include <stdlib.h>
    … …  
    3635#include <ctype.h>
    3736#include <stdarg.h>
    38 #ifdef HAVE_ALLOCA_H
    39 # include <alloca.h>
    40 #endif
    4137#if !defined(_MSC_VER)
    4238# include <unistd.h>
    … …  
    5450*   Defined Constants And Macros                                               *
    5551*******************************************************************************/
    56 /*#define DEBUG*/
    57 #ifdef DEBUG
     52#if 0
    5853# define dprintf(a)             printf a
    5954# define dump(pb, cb, offBase)  depHexDump(pb,cb,offBase)
    … …  
    576571 * @param   cbSyms      Size of the symbol section.
    577572 */
    578 int kDepObjCOFFParseCV8SymbolSection(const KU8 *pbSyms, KSIZE cbSyms)
     573int kDepObjCOFFParseCV8SymbolSection(const KU8 *pbSyms, KU32 cbSyms)
    579574{
    580575    char const *    pchStrTab  = NULL;
    … …  
    765760    int                         rc;
    766761
    767     printf("COFF file!\n");
     762    dprintf(("COFF file!\n"));
    768763
    769764    for (iSHdr = 0; iSHdr < cSHdrs; iSHdr++)
    … …  
    784779                return rc;
    785780        }
    786         printf("#%d: %.8s\n", iSHdr, paSHdrs[iSHdr].Name);
     781        dprintf(("#%d: %.8s\n", iSHdr, paSHdrs[iSHdr].Name));
    787782    }
    788783    return rcRet;

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

    r2884 r2894  
    574574 * @param   pszCwd              The current directory.
    575575 * @param   fWatcomBrainDamage  The wcc/wcc386 workaround.
     576 * @param   papszPostCmdArgs    The post command and it's arguments.
     577 * @param   cPostCmdArgs        Number of post command argument, including the
     578 *                              command.  Zero if no post command scheduled.
    576579 * @param   pcbMsg              Where to return the message length.
    577580 */
    578581static void *kSubmitComposeJobMessage(const char *pszExecutable, char **papszArgs, char **papszEnvVars,
    579                                       const char *pszCwd, int fWatcomBrainDamage, uint32_t *pcbMsg)
     582                                      const char *pszCwd, int fWatcomBrainDamage,
     583                                      char **papszPostCmdArgs, uint32_t cPostCmdArgs, uint32_t *pcbMsg)
    580584{
    581585    size_t   cbTmp;
    … …  
    613617    cbMsg += 1;
    614618
     619    cbMsg += sizeof(cPostCmdArgs);
     620    for (i = 0; i < cPostCmdArgs; i++)
     621        cbMsg += strlen(papszPostCmdArgs[i]) + 1;
     622
    615623    /*
    616624     * Compose the message.
    … …  
    618626    pbMsg = pbCursor = xmalloc(cbMsg);
    619627
     628    /* header */
    620629    memcpy(pbCursor, &cbMsg, sizeof(cbMsg));
    621630    pbCursor += sizeof(cbMsg);
    … …  
    623632    pbCursor += sizeof("JOB");
    624633
     634    /* executable. */
    625635    cbTmp = strlen(pszExecutable) + 1;
    626636    memcpy(pbCursor, pszExecutable, cbTmp);
    627637    pbCursor += cbTmp;
    628638
     639    /* cwd */
    629640    cbTmp = strlen(pszCwd) + 1;
    630641    memcpy(pbCursor, pszCwd, cbTmp);
    631642    pbCursor += cbTmp;
    632643
     644    /* argument */
    633645    memcpy(pbCursor, &cArgs, sizeof(cArgs));
    634646    pbCursor += sizeof(cArgs);
    … …  
    642654    assert(i == cArgs);
    643655
     656    /* environment */
    644657    memcpy(pbCursor, &cEnvVars, sizeof(cEnvVars));
    645658    pbCursor += sizeof(cEnvVars);
    … …  
    652665    assert(i == cEnvVars);
    653666
     667    /* flags */
    654668    *pbCursor++ = fWatcomBrainDamage != 0;
    655669
     670    /* post command */
     671    memcpy(pbCursor, &cPostCmdArgs, sizeof(cPostCmdArgs));
     672    pbCursor += sizeof(cPostCmdArgs);
     673    for (i = 0; i < cPostCmdArgs; i++)
     674    {
     675        cbTmp = strlen(papszPostCmdArgs[i]) + 1;
     676        memcpy(pbCursor, papszPostCmdArgs[i], cbTmp);
     677        pbCursor += cbTmp;
     678    }
     679    assert(i == cPostCmdArgs);
     680
    656681    assert(pbCursor - pbMsg == (size_t)cbMsg);
    657682
    658     /* done */
     683    /*
     684     * Done.
     685     */
    659686    *pcbMsg = cbMsg;
    660687    return pbMsg;
    … …  
    13391366            "usage: %s [-Z|--zap-env] [-E|--set <var=val>] [-U|--unset <var=val>]\n"
    13401367            "           [-C|--chdir <dir>] [--wcc-brain-damage]\n"
    1341             "           [-3|--32-bit] [-6|--64-bit] [-v] -- <program> [args]\n"
     1368            "           [-3|--32-bit] [-6|--64-bit] [-v]\n"
     1369            "           [-P|--post-cmd <cmd> [args]] -- <program> [args]\n"
    13421370            "   or: %s --help\n"
    13431371            "   or: %s --version\n"
    … …  
    13621390            "  -v,--verbose\n"
    13631391            "    More verbose execution.\n"
     1392            "  -P|--post-cmd <cmd> ...\n"
     1393            "    For running a built-in command on the output, specifying the command\n"
     1394            "    and all it's parameters.  Currently supported commands:\n"
     1395            "        kDepObj\n"
    13641396            "  -V,--version\n"
    13651397            "    Show the version number.\n"
    … …  
    13831415    const char     *pszExecutable       = NULL;
    13841416    const char     *pszCwd              = NULL;
     1417    int             iPostCmd            = argc;
     1418    int             cPostCmdArgs        = 0;
    13851419    unsigned        cBitsWorker         = g_cArchBits;
    13861420    int             fWatcomBrainDamage  = 0;
    … …  
    14571491                else if (strcmp(pszArg, "chdir") == 0)
    14581492                    chOpt = 'C';
     1493                else if (strcmp(pszArg, "post-cmd") == 0)
     1494                    chOpt = 'P';
    14591495                else if (strcmp(pszArg, "32-bit") == 0)
    14601496                    chOpt = '3';
    … …  
    14891525                        else
    14901526                        {
    1491                             errx(1, "Option -%c requires an value!", chOpt);
     1527                            errx(1, "Option -%c requires a value!", chOpt);
    14921528                            return usage(stderr, argv[0]);
    14931529                        }
    … …  
    15241560                        return rcExit;
    15251561
     1562                    case 'P':
     1563                        if (cPostCmdArgs > 0)
     1564                            return errx(1, "The -P option can only be used once!");
     1565                        if (*pszArg != '\0')
     1566                            return errx(1, "The cmd part of the -P needs to be a separate argument!");
     1567                        iPostCmd = ++iArg;
     1568                        if (iArg >= argc)
     1569                            return errx(1, "The -P option requires a command following it!");
     1570                        while (iArg < argc && strcmp(argv[iArg], "--") != 0)
     1571                            iArg++;
     1572                        cPostCmdArgs = iArg - iPostCmd;
     1573                        iArg--;
     1574                        break;
     1575
    15261576                    case '3':
    15271577                        cBitsWorker = 32;
    … …  
    15631613        uint32_t        cbMsg;
    15641614        void           *pvMsg   = kSubmitComposeJobMessage(pszExecutable, &argv[iArg], papszEnv, szCwd,
    1565                                                            fWatcomBrainDamage, &cbMsg);
     1615                                                           fWatcomBrainDamage, &argv[iPostCmd], cPostCmdArgs, &cbMsg);
    15661616        PWORKERINSTANCE pWorker = kSubmitSelectWorkSpawnNewIfNecessary(cBitsWorker, cVerbosity);
    15671617        if (pWorker)

  • trunk/src/lib/quote_argv.c

    r2851 r2894  
    114114            || (   !fWatcomBrainDamage
    115115                && (pszProblem = (const char *)memchr(pszOrg, '=',  cchOrg)) != NULL)
     116            || (   fWatcomBrainDamage
     117                && (pszProblem = (const char *)memchr(pszOrg, '\\', cchOrg)) != NULL)
    116118            )
    117119        {
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