tclobjv.c

Bug Summary

File:	d/tclobjv.c
Warning:	line 1714, column 24 Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name tclobjv.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/isvv/naviserver/nsd -resource-dir /usr/local/lib/clang/15.0.0 -D _FORTIFY_SOURCE=2 -D NDEBUG -D SYSTEM_MALLOC -I ../include -I /usr/include/tcl8.6 -D HAVE_CONFIG_H -internal-isystem /usr/local/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c99 -fdebug-compilation-dir=/home/isvv/naviserver/nsd -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-checker alpha -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-07-23-130959-11103-1 -x c tclobjv.c
1/*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://mozilla.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* Alternatively, the contents of this file may be used under the terms
* of the GNU General Public License (the "GPL"), in which case the
* provisions of GPL are applicable instead of those above.  If you wish
* to allow use of your version of this file only under the terms of the
* GPL and not to allow others to use your version of this file under the
* License, indicate your decision by deleting the provisions above and
* replace them with the notice and other provisions required by the GPL.
* If you do not delete the provisions above, a recipient may use your
* version of this file under either the License or the GPL.
*/


24/*
* tclobjv.c --
*
*      Routines for parsing the options and arguments passed to Tcl commands.
*
*/

31#include "nsd.h"

33#define VALUE_SUPPLIED(((void *)(intptr_t)(1))) (INT2PTR(NS_TRUE)((void *)(intptr_t)(1)))


36/*
* Static functions defined in this file.
*/

40static Tcl_FreeInternalRepProc FreeSpecObj;
41static Tcl_DupInternalRepProc  DupSpec;
42static Tcl_UpdateStringProc    UpdateStringOfSpec;
43static Tcl_SetFromAnyProc      SetSpecFromAny;

45static Ns_ObjvProc ObjvTcl;
46static Ns_ObjvProc ObjvTclArgs;

48static void FreeSpecs(Ns_ObjvSpec *specPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

51static int SetValue(Tcl_Interp *interp, const char *key, Tcl_Obj *valueObj)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));

54static void WrongNumArgs(const Ns_ObjvSpec *optSpec, Ns_ObjvSpec *argSpec,
                       Tcl_Interp *interp, int objc, Tcl_Obj *const* objv);

57static int GetOptIndexObjvSpec(Tcl_Obj *obj, const Ns_ObjvSpec *tablePtr, int *idxPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3)));
59static int GetOptIndexSubcmdSpec(Tcl_Interp *interp, Tcl_Obj *obj, const char *msg, const Ns_SubCmdSpec *tablePtr, int *idxPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(3)__attribute__((__nonnull__(3))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4))) NS_GNUC_NONNULL(5)__attribute__((__nonnull__(5)));

62static void UpdateStringOfMemUnit(Tcl_Obj *objPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1)));

65static int SetMemUnitFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

68static void AppendRange(Ns_DStringTcl_DString *dsPtr, const Ns_ObjvValueRange *r)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2)));

71/*
* Static variables defined in this file.
*/
74static const Tcl_ObjType *intTypePtr;

76static const Tcl_ObjType specType = {
  "ns:spec",
  FreeSpecObj,
  DupSpec,
  UpdateStringOfSpec,
  SetSpecFromAny
82};

84static const Tcl_ObjType memUnitType = {
  "ns:mem_unit",
  NULL((void*)0),
  NULL((void*)0),
  UpdateStringOfMemUnit,
  SetMemUnitFromAny
90};

92
93/*
*----------------------------------------------------------------------
*
* NsTclInitSpecType --
*
*      Initialize ns:spec Tcl_Obj type.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

109void
110NsTclInitSpecType(void)
111{
  Tcl_RegisterObjType(&specType);
113}

115
116/*
*----------------------------------------------------------------------
*
* GetOptIndexObjvSpec --
*
*      Process options similar to Tcl_GetIndexFromObj() but allow
*      only options (starting with a "-"), allow only exact matches
*      and don't cache results as internal reps.
*
*      Background: Tcl_GetIndexFromObj() validates internal reps
*      based on the pointer of the base string table, which works
*      only reliably with *static* string tables. Since NaviServer
*      can't use static string tables, these tables are allocated on
*      the stack. This can lead to mix-ups for shared objects with
*      the consequence the resulting indices might be incorrect,
*      leading to potential crashes. In order to allow caching, it
*      should be possible to validate the entries based on other
*      means, but this requires a different interface.
*
* Results:
*      Tcl result.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
143static int
144GetOptIndexObjvSpec(Tcl_Obj *obj, const Ns_ObjvSpec *tablePtr, int *idxPtr)
145{
  const char *key;
  int         result = TCL_ERROR1;

  NS_NONNULL_ASSERT(obj != NULL)((void) (0));
  NS_NONNULL_ASSERT(tablePtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(idxPtr != NULL)((void) (0));

  key = Tcl_GetString(obj);
  if (*key == '-') {
      const Ns_ObjvSpec *entryPtr;
      int                idx;

      for (entryPtr = tablePtr, idx = 0; entryPtr->key != NULL((void*)0);  entryPtr++, idx++) {
          const char *p1, *p2;

          for (p1 = key, p2 = entryPtr->key; *p1 == *p2; p1++, p2++) {
              if (*p1 == '\0') {
                  /*
                   * Both words are at their ends. Match is successful.
                   */
                  *idxPtr = idx;
                  result = TCL_OK0;
                  break;
              }
          }
          if (*p1 == '\0') {
              /*
               * The value is an abbreviation for this entry or was
               * matched in the inner loop.
               */
              break;
          }
      }
  }

  return result;
182}

184
185/*
*----------------------------------------------------------------------
*
* Ns_ParseObjv --
*
*      Process objv according to given option and arg specs.
*
* Results:
*      NS_OK or NS_ERROR.
*
* Side effects:
*      Depends on the Ns_ObjvTypeProcs which run.
*
*----------------------------------------------------------------------
*/
200Ns_ReturnCode
201Ns_ParseObjv(Ns_ObjvSpec *optSpec, Ns_ObjvSpec *argSpec, Tcl_Interp *interp,
           int offset, int objc, Tcl_Obj *const* objv)
203{
  Ns_ObjvSpec  *specPtr;
  int           optIndex, requiredArgs = 0, remain = (objc - offset);

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));

  /*
   * In case, the number of actual arguments is equal to the number
   * of required arguments, skip option processing and use the
   * provided argument for the required arguments. This way,
   * e.g. "ns_md5 --" will compute the checksum of "--" instead of
   * spitting out an error message about a missing input string.
   */
  if (likely(argSpec != NULL)(__builtin_expect((argSpec != ((void*)0)), 1)) && likely(optSpec != NULL)(__builtin_expect((optSpec != ((void*)0)), 1))) {
      /*
       * Count required args.
       */
      for (specPtr = argSpec; specPtr != NULL((void*)0) && specPtr->key != NULL((void*)0); specPtr++) {
          if (unlikely(specPtr->key[0] == '?')(__builtin_expect((specPtr->key[0] == '?'), 0))) {
              break;
          }
          requiredArgs++;
      }
      if (requiredArgs+offset == objc) {
          /*
           * No need to process optional parameters.
           */
          optSpec = NULL((void*)0);
      }
  }

  if (likely(optSpec != NULL)(__builtin_expect((optSpec != ((void*)0)), 1)) && likely(optSpec->key != NULL)(__builtin_expect((optSpec->key != ((void*)0)), 1))) {

      while (remain > 0) {
          Tcl_Obj *obj = objv[objc - remain];
          int      result;

240#ifdef NS_TCL_PRE87
          /*
           * In case a Tcl_Obj has no stringrep (e.g. a pure/proper
           * byte array), it is assumed that this cannot be an
           * option flag (starting with a '-'). Since
           * GetOptIndexObjvSpec() and Tcl_GetIndexFromObjStruct()
           * create on demand string representations, the "pure"
           * property will be lost and Tcl cannot distinguish later
           * whether it can use the string representation as byte
           * array or not. Fortunately, this dangerous fragility is
           * gone in Tcl 8.7.
           */
          if (obj->bytes == NULL((void*)0)) {
              break;
          }
255#endif
          result = Tcl_IsShared(obj)((obj)->refCount > 1) ?
              GetOptIndexObjvSpec(obj, optSpec, &optIndex) :
              Tcl_GetIndexFromObjStruct(NULL((void*)0), obj, optSpec,
                                        sizeof(Ns_ObjvSpec), "option",
                                        TCL_EXACT1, &optIndex);
          if (result != TCL_OK0) {
              break;
          }

          --remain;
          specPtr = optSpec + optIndex;
          result = specPtr->proc(specPtr, interp, &remain, objv + (objc - remain));

          if (result == TCL_BREAK3) {
              break;
          } else if (result != TCL_OK0) {
              return NS_ERROR;
          }
      }
  }
  if (unlikely(argSpec == NULL)(__builtin_expect((argSpec == ((void*)0)), 0))) {
      if (remain > 0) {
      badargs:
          WrongNumArgs(optSpec, argSpec, interp, offset, objv);
          return NS_ERROR;
      }
      return NS_OK;
  }

  for (specPtr = argSpec; specPtr != NULL((void*)0) && specPtr->key != NULL((void*)0); specPtr++) {
      if (unlikely(remain == 0)(__builtin_expect((remain == 0), 0))) {
          if (unlikely(specPtr->key[0] != '?')(__builtin_expect((specPtr->key[0] != '?'), 0))) {
              goto badargs; /* Too few args. */
          }
          return NS_OK;
      }
      if (unlikely(specPtr->proc(specPtr, interp, &remain, objv + (objc - remain)))(__builtin_expect((specPtr->proc(specPtr, interp, &remain
, objv + (objc - remain))), 0))
          != TCL_OK0) {
          return NS_ERROR;
      }
  }
  if (unlikely(remain > 0)(__builtin_expect((remain > 0), 0))) {
      goto badargs; /* Too many args. */
  }

  return NS_OK;
302}

304
305/*
*----------------------------------------------------------------------
*
* Ns_CheckWideRange --
*
*      Helper function for range checking based on Tcl_WideInt specification.
*      In error cases, the function leaves an error message in the interpreter.
*
* Results:
*      TCL_OK or TCL_ERROR;
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
321int
322Ns_CheckWideRange(Tcl_Interp *interp, const char *name, const Ns_ObjvValueRange *r, Tcl_WideInt value)
323{
  int result;

  if (r == NULL((void*)0) || (value >= r->minValue && value <= r->maxValue)) {
      /*
       * No range or valid range.
       */
      result = TCL_OK0;
  } else {
      /*
       * Invalid range.
       */
      Tcl_DString ds, *dsPtr = &ds;

      Tcl_DStringInit(dsPtr);
      Tcl_DStringAppend(dsPtr, "expected integer in range ", 26);
      AppendRange(dsPtr, r);
      Ns_DStringPrintf(dsPtr, " for '%s', but got %" TCL_LL_MODIFIER"l" "d", name, value);
      Tcl_DStringResult(interp, dsPtr);

      result = TCL_ERROR1;
  }
  return result;
346}

348
349/*
*----------------------------------------------------------------------
*
* Ns_CheckTimeRange --
*
*      Helper function for time range checking based on Ns_Times.
*      In error cases, the function leaves an error message in the interpreter.
*
* Results:
*      TCL_OK or TCL_ERROR;
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
365int
366Ns_CheckTimeRange(Tcl_Interp *interp, const char *name, const Ns_ObjvTimeRange *r, Ns_Time *value)
367{
  int result;
  Tcl_DString ds0;

  Tcl_DStringInit(&ds0);
  //fprintf(stderr, "check time range '%s'\n", Ns_DStringAppendTime(&ds0, value));

  if (r == NULL((void*)0)
      || (Ns_DiffTime(value, &r->minValue, NULL((void*)0)) >= 0
          && Ns_DiffTime(value, &r->maxValue, NULL((void*)0)) <= 0) ) {
      /*
       * No range or valid range.
       */
      result = TCL_OK0;
  } else {
      /*
       * Invalid range.
       */
      Tcl_DString ds, *dsPtr = &ds;

      Tcl_DStringInit(dsPtr);
      Tcl_DStringAppend(dsPtr, "expected time value in range [", -1);
      if (r->maxValue.sec == LONG_MAX9223372036854775807L) {
          Ns_DStringAppendTime(dsPtr, &r->minValue);
          Tcl_DStringAppend(dsPtr, "s, MAX],", 8);
      } else {
          Ns_DStringAppendTime(dsPtr, &r->minValue);
          Tcl_DStringAppend(dsPtr, "s , ", 5);
          Ns_DStringAppendTime(dsPtr, &r->maxValue);
          Tcl_DStringAppend(dsPtr, "],", 2);
      }
      Ns_DStringPrintf(dsPtr, " for '%s', but got ", name);
      (void)Ns_DStringAppendTime(dsPtr, value);

      Tcl_DStringResult(interp, dsPtr);

      result = TCL_ERROR1;
  }
  return result;
406}

408/*
*----------------------------------------------------------------------
*
* Ns_ObjvInt,
* Ns_ObjvUShort,
* Ns_ObjvLong,
* Ns_ObjvWideInt,
* Ns_ObjvDouble
*
*      Consume exactly one argument, returning its value into dest.
*      A typical use case for Ns_ObjvUShort is for ports.
*
* Results:
*      TCL_OK or TCL_ERROR;
*
* Side effects:
*      Argument maybe converted to type specific internal rep.
*
*----------------------------------------------------------------------
*/
428int
429Ns_ObjvInt(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
         Tcl_Obj *const* objv)
431{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      int *dest = spec->dest;

      result = Tcl_GetIntFromObj(interp, objv[0], dest);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          if (Ns_CheckWideRange(interp, spec->key, spec->arg, (Tcl_WideInt)*dest) == TCL_OK0) {
              *objcPtr -= 1;
          } else {
              result = TCL_ERROR1;
          }
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
453}

455int
456Ns_ObjvUShort(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
            Tcl_Obj *const* objv)
458{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      int intValue;

      result = Tcl_GetIntFromObj(interp, objv[0], &intValue);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          /*
           * Check permissible values (USHRT_MAX)
           */
          if (intValue > 65535 || intValue < 0) {
              Ns_TclPrintfResult(interp, "value %d out of range (0..65535)", intValue);
              result = TCL_ERROR1;
          } else {
              unsigned short *dest = spec->dest;

              *dest = (unsigned short)intValue;
              *objcPtr -= 1;
          }
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
487}

489int
490Ns_ObjvLong(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
          Tcl_Obj *const* objv)
492{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      long *dest = spec->dest;

      result = Tcl_GetLongFromObj(interp, objv[0], dest);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          if (Ns_CheckWideRange(interp, spec->key, spec->arg, (Tcl_WideInt)*dest) == TCL_OK0) {
              *objcPtr -= 1;
          } else {
              result = TCL_ERROR1;
          }
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
514}

516int
517Ns_ObjvWideInt(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
             Tcl_Obj *const* objv)
519{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      Tcl_WideInt *dest = spec->dest;

      result = Tcl_GetWideIntFromObj(interp, objv[0], dest);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          if (Ns_CheckWideRange(interp, spec->key, spec->arg, *dest) == TCL_OK0) {
              *objcPtr -= 1;
          } else {
              result = TCL_ERROR1;
          }
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
541}

543int
544Ns_ObjvDouble(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
            Tcl_Obj *const* objv)
546{
  int     result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      double *dest = spec->dest;

      result = Tcl_GetDoubleFromObj(interp, objv[0], dest);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          *objcPtr -= 1;
      }
  }
  else {
      result = TCL_ERROR1;
  }

  return result;
564}

566
567/*
*----------------------------------------------------------------------
*
* Ns_ObjvBool --
*
*      If spec->arg is NULL consume exactly one argument and attempt
*      conversion to a boolean value.  Otherwise, spec->arg is
*      treated as an int and placed into spec->dest with zero args
*      consumed.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*      Tcl_Obj maybe converted to boolean type.
*
*----------------------------------------------------------------------
*/

586int
587Ns_ObjvBool(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr, Tcl_Obj *const* objv)
588{
  int *dest, result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  dest = spec->dest;

  if (spec->arg != NULL((void*)0)) {
      *dest = PTR2INT(spec->arg)((int)(intptr_t)(spec->arg));
      result = TCL_OK0;
  } else {
      if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
          result = Tcl_GetBooleanFromObj(interp, objv[0], dest);
          if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
              *objcPtr -= 1;
          }
      } else {
          Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
          result = TCL_ERROR1;
      }
  }
  return result;
610}

612
613/*
*----------------------------------------------------------------------
*
* Ns_ObjvString --
*
*      Consume exactly one argument, returning a pointer to its
*      string representation into *spec->dest.
*
*      If spec->arg is != NULL it is assumed to be a pointer to an
*      int and the returned string length will be left in it.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

633int
634Ns_ObjvString(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
            Tcl_Obj *const* objv)
636{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      const char **dest = spec->dest;

      *dest = Tcl_GetStringFromObj(objv[0], (int *) spec->arg);
      *objcPtr -= 1;
      result = TCL_OK0;
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
653}

655/*
*----------------------------------------------------------------------
*
* Ns_ObjvEval --
*
*      Consume exactly one argument, returning a pointer to the
*      result of eval into *spec->dest.
*
*      If spec->arg is != NULL it is assumed to be a pointer to an
*      int and the returned string length will be left in it.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

675int
676Ns_ObjvEval(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
            Tcl_Obj *const* objv)
678{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      const char **dest = spec->dest;

      result = Tcl_EvalObjEx(interp, objv[0], 0);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          *dest = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), (int *) spec->arg);
          *objcPtr -= 1;
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }
  return result;
696}

698
699/*
*----------------------------------------------------------------------
*
* Ns_ObjvByteArray --
*
*      Consume exactly one argument, returning a pointer to the
*      raw bytes into *spec->dest.
*
*      If spec->arg is != NULL it is assumed to be a pointer to an
*      int and the number of bytes will be left in it.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

719int
720Ns_ObjvByteArray(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
            Tcl_Obj *const* objv)
722{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      const unsigned char **dest = spec->dest;

      *dest = Tcl_GetByteArrayFromObj(objv[0], (int *) spec->arg);
      *objcPtr -= 1;
      result = TCL_OK0;
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }
  return result;
738}

740
741/*
*----------------------------------------------------------------------
*
* Ns_ObjvObj --
*
*      Consume exactly one argument, returning its pointer into dest
*      with no conversion.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

758int
759Ns_ObjvObj(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
         Tcl_Obj *const* objv)
761{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      Tcl_Obj **dest = spec->dest;

      *dest = objv[0];
      *objcPtr -= 1;
      result = TCL_OK0;
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
778}

780
781/*
*----------------------------------------------------------------------
*
* Ns_ObjvTime --
*
*      Consume exactly one argument, returning a pointer to the
*      Ns_Time into *spec->dest.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

798int
799Ns_ObjvTime(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
          Tcl_Obj *const* objv)
801{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      Ns_Time **dest = spec->dest;

      result = Ns_TclGetTimePtrFromObj(interp, objv[0], dest);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          result = Ns_CheckTimeRange(interp, spec->key, spec->arg, *dest);
      }

      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          *objcPtr -= 1;
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
823}

825
826/*
*----------------------------------------------------------------------
*
* Ns_TclGetTimeFromObj --
*
*      Return the internal value of an Ns_Time Tcl_Obj.  If the value is
*      specified as integer, the value is interpreted as seconds.
*
* Results:
*      TCL_OK or TCL_ERROR if not a valid Ns_Time.
*
* Side effects:
*      Object is converted to Ns_Time type if necessary.
*
*----------------------------------------------------------------------
*/
842void
843NsTclInitMemUnitType(void)
844{
  intTypePtr = Tcl_GetObjType("int");
  if (intTypePtr == NULL((void*)0)) {
      Tcl_Panic("NsTclInitObjs: no int type");
  }
  Tcl_RegisterObjType(&memUnitType);
850}

852static void
853UpdateStringOfMemUnit(Tcl_Obj *objPtr)
854{
  long     memUnit;
  int      len;
  char     buf[(TCL_INTEGER_SPACE24) + 1];

  NS_NONNULL_ASSERT(objPtr != NULL)((void) (0));

  memUnit = PTR2INT((void *) &objPtr->internalRep)((int)(intptr_t)((void *) &objPtr->internalRep));
  len = ns_uint64toa(buf, (uint64_t)memUnit);
  Ns_TclSetStringRep(objPtr, buf, len);
864}

866static int
867SetMemUnitFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr)
868{
  Tcl_WideInt memUnit = 0;
  int         result = TCL_OK0;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(objPtr != NULL)((void) (0));

  if (objPtr->typePtr == intTypePtr) {
      long longValue;
      /*
       * When the type is "int", the memory unit is in bytes.
       */
      if (Tcl_GetLongFromObj(interp, objPtr, &longValue) != TCL_OK0) {
          result = TCL_ERROR1;
      } else {
          memUnit = longValue;
      }
  } else {
      Ns_ReturnCode status;

      status = Ns_StrToMemUnit(Tcl_GetString(objPtr), &memUnit);
      if (status == NS_ERROR) {
          result = TCL_ERROR1;
      }
  }

  if (result == TCL_OK0) {
      Ns_TclSetTwoPtrValue(objPtr, &memUnitType, INT2PTR(memUnit)((void *)(intptr_t)(memUnit)), NULL((void*)0));
  }

  return result;
899}

901/*
*----------------------------------------------------------------------
*
* Ns_TclGetMemUnitFromObj --
*
*      Convert a Tcl_Obj with a string value of a memory unit into a Tcl_WideInt.
*      It has the same interface as e.g. Tcl_GetWideIntFromObj().
*
* Results:
*      TCL_OK or TCL_ERROR if not a valid memory unit string.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

918int
919Ns_TclGetMemUnitFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_WideInt *memUnitPtr)
920{
  int  result = TCL_OK0;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(objPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(memUnitPtr != NULL)((void) (0));

  /*
   * Many values come in already as int values. No need to convert
   * these to memUnitType.
   */
  if (objPtr->typePtr == intTypePtr) {
      int intValue;

      if (likely(Tcl_GetIntFromObj(interp, objPtr, &intValue) != TCL_OK)(__builtin_expect((Tcl_GetIntFromObj(interp, objPtr, &intValue
) != 0), 1))) {
          result = TCL_ERROR1;
      } else {
          *memUnitPtr = (Tcl_WideInt)intValue;
      }
  } else {
      /*
       * When the values are already in memUnitType, get the value
       * directly, otherwise convert.
       */
      if (objPtr->typePtr != &memUnitType) {

          if (unlikely(Tcl_ConvertToType(interp, objPtr, &memUnitType) != TCL_OK)(__builtin_expect((Tcl_ConvertToType(interp, objPtr, &memUnitType
) != 0), 0))) {
              Ns_TclPrintfResult(interp, "invalid memory unit '%s'; "
                                 "valid units kB, MB, GB, KiB, MiB, and GiB",
                                 Tcl_GetString(objPtr));
              result = TCL_ERROR1;
          }
      }
      if (likely(objPtr->typePtr == &memUnitType)(__builtin_expect((objPtr->typePtr == &memUnitType), 1
))) {
          *memUnitPtr =  (Tcl_WideInt)objPtr->internalRep.twoPtrValue.ptr1;
      }
  }

  return result;
959}

961
962/*
*----------------------------------------------------------------------
*
* Ns_ObjvMemUnit --
*
*      Consume exactly one argument, returning a pointer to the
*      memUnit (Tcl_WideInt) into *spec->dest.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

979int
980Ns_ObjvMemUnit(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
          Tcl_Obj *const* objv)
982{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      Tcl_WideInt *dest = spec->dest;

      result = Ns_TclGetMemUnitFromObj(interp, objv[0], dest);

      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          if (Ns_CheckWideRange(interp, spec->key, spec->arg, (Tcl_WideInt)*dest) == TCL_OK0) {
              *objcPtr -= 1;
          } else {
              result = TCL_ERROR1;
          }
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
1005}


1008/*
*----------------------------------------------------------------------
*
* Ns_ObjvSet --
*
*      Consume exactly one argument, returning a pointer to the
*      Ns_Set into *spec->dest.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

1025int
1026Ns_ObjvSet(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
          Tcl_Obj *const* objv)
1028{
  int result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      Ns_Set **dest = spec->dest;

      result = Ns_TclGetSet2(interp, Tcl_GetString(objv[0]), dest);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          *objcPtr -= 1;
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
1046}

1048
1049/*
*----------------------------------------------------------------------
*
* Ns_ObjvIndex --
*
*      Match the next argument against the keys in the specified
*      table, returning the value at the index of the first match
*      into dest. It is an error for the argument to contain anything
*      but one of the table keys.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1068int
1069Ns_ObjvIndex(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
           Tcl_Obj *const* objv)
1071{
  const Ns_ObjvTable *tablePtr;
  int                *dest, tableIdx, result;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  tablePtr = spec->arg;
  dest     = spec->dest;

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      result = Tcl_GetIndexFromObjStruct(interp, objv[0], tablePtr,
                                         sizeof(Ns_ObjvTable), "option",
                                         TCL_EXACT1, &tableIdx);
      if (result == TCL_OK0) {
          *dest = (int)tablePtr[tableIdx].value;
          *objcPtr -= 1;
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
1094}

1096
1097/*
*----------------------------------------------------------------------
*
* Ns_ObjvFlags --
*
*      Treat the next argument as a list of flags and compare them
*      all with the keys in the specified table.  As flags are
*      matched the values are ORed togethter and the result is
*      returned in dest.  An unknown flag causes an error.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*      Arg may be converted to list representation.
*
*----------------------------------------------------------------------
*/

1116int
1117Ns_ObjvFlags(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr,
           Tcl_Obj *const* objv)
1119{
  unsigned int       *dest;
  const Ns_ObjvTable *tablePtr;
  int                 result, tableIdx = 0;
  Tcl_Obj           **flagv;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));
  NS_NONNULL_ASSERT(interp != NULL)((void) (0));

  dest = spec->dest;
  tablePtr = spec->arg;

  if (*objcPtr < 1) {
      result = TCL_ERROR1;
  } else {
      int flagc;

      result = Tcl_ListObjGetElements(interp, objv[0], &flagc, &flagv);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          if (likely(flagc > 0)(__builtin_expect((flagc > 0), 1))) {
              int i;

              for (i = 0; i < flagc; ++i) {
                  result = Tcl_GetIndexFromObjStruct(interp, flagv[i], tablePtr,
                                                     sizeof(Ns_ObjvTable), "flag",
                                                     TCL_EXACT1, &tableIdx);
                  if (unlikely(result != TCL_OK)(__builtin_expect((result != 0), 0))) {
                      break;
                  }
              }
          } else {
              Ns_TclPrintfResult(interp, "blank flag specification");
              result = TCL_ERROR1;
          }
      }
  }

  if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
      *dest |= tablePtr[tableIdx].value;
      *objcPtr -= 1;
  }

  return result;
1162}

1164
1165/*
*----------------------------------------------------------------------
*
* Ns_ObjvBreak --
*
*          Handle '--' option/argument separator.
*
* Results:
*      Always TCL_BREAK.
*
* Side effects:
*      Option processing will end successfully, argument processing
*      will begin.
*
*----------------------------------------------------------------------
*/

1182int
1183Ns_ObjvBreak(Ns_ObjvSpec *UNUSED(spec)UNUSED_spec __attribute__((__unused__)), Tcl_Interp *UNUSED(interp)UNUSED_interp __attribute__((__unused__)),
           int *UNUSED(objcPtr)UNUSED_objcPtr __attribute__((__unused__)), Tcl_Obj *const* UNUSED(objv)UNUSED_objv __attribute__((__unused__)))
1185{
  return TCL_BREAK3;
1187}

1189
1190/*
*----------------------------------------------------------------------
*
* Ns_ObjvArgs --
*
*          Count all remaining arguments, leaving zero left
*          unprocessed.
*
* Results:
*          Always TCL_OK.
*
* Side effects:
*          Argument processing will end successfully.
*
*----------------------------------------------------------------------
*/

1207int
1208Ns_ObjvArgs(Ns_ObjvSpec *spec, Tcl_Interp *UNUSED(interp)UNUSED_interp __attribute__((__unused__)),
          int *objcPtr, Tcl_Obj *const* UNUSED(objv)UNUSED_objv __attribute__((__unused__)))
1210{
  NS_NONNULL_ASSERT(spec != NULL)((void) (0));

  *((int *) spec->dest) = *objcPtr;
  *objcPtr = 0;

  return TCL_OK0;
1217}

1219
1220/*
*----------------------------------------------------------------------
*
* Ns_ObjvServer --
*
*      Get server from argument, consume it, put result into "dest".
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1236int
1237Ns_ObjvServer(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr, Tcl_Obj *const* objv)
1238{
  NsServer **dest;
  int        result = TCL_OK0;

  NS_NONNULL_ASSERT(spec != NULL)((void) (0));
  NS_NONNULL_ASSERT(interp != NULL)((void) (0));

  dest = spec->dest;

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1)) && likely(dest != NULL)(__builtin_expect((dest != ((void*)0)), 1))) {
      NsServer *servPtr = NsGetServer(Tcl_GetString(objv[0]));

      if (likely(servPtr != NULL)(__builtin_expect((servPtr != ((void*)0)), 1))) {
          *dest = servPtr;
          *objcPtr -= 1;
      } else {
          Ns_TclPrintfResult(interp, "invalid server: '%s'", Tcl_GetString(objv[0]));
          result = TCL_ERROR1;
      }
  } else {
      result = TCL_ERROR1;
  }

  return result;
1262}

1264
1265/*
*----------------------------------------------------------------------
*
* NsTclParseArgsObjCmd --
*
*          Implements "ns_parseargs".
*
* Results:
*          Tcl result.
*
* Side effects:
*          Specification may be converted to ns:spec obj type.
*
*----------------------------------------------------------------------
*/

1281int
1282NsTclParseArgsObjCmd(ClientData UNUSED(clientData)UNUSED_clientData __attribute__((__unused__)), Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
1283{
  Tcl_Obj  **argv, *argsObj;
  int        argc, status = TCL_OK0;

  if (objc != 3) {
      Tcl_WrongNumArgs(interp, 1, objv, "specification args");
      return TCL_ERROR1;
  }
  /*
   * In case both arguments are shared (objv[1] == objv[2]), make
   * sure to decouple these, since Tcl_ListObjGetElements() and
   * Tcl_ConvertToType() would shimmer on the shared object.
   */
  if (objv[2] == objv[1]) {
      argsObj = Tcl_DuplicateObj(objv[2]);
      Tcl_IncrRefCount(argsObj)++(argsObj)->refCount;
  } else {
      argsObj = objv[2];
  }

  if (Tcl_ListObjGetElements(interp, argsObj, &argc, &argv) != TCL_OK0
      || Tcl_ConvertToType(interp, objv[1], &specType) != TCL_OK0) {
      status = TCL_ERROR1;

  } else {
      Ns_ObjvSpec   *opts, *args;

      opts = objv[1]->internalRep.twoPtrValue.ptr1;
      args = objv[1]->internalRep.twoPtrValue.ptr2;
      if (Ns_ParseObjv(opts, args, interp, 0, argc, argv) != NS_OK) {
          status = TCL_ERROR1;

      } else {
          bool_Bool         doneOpts = NS_FALSE0;
          Ns_ObjvSpec *specPtr = opts;

          /*
           * Set defaults for args which were passed no values and
           * reset the dest pointer for subsequent calls to this
           * command.
           */

          for (;;) {
              if (specPtr->key == NULL((void*)0)) {
                  if (doneOpts) {
                      break;
                  }
                  doneOpts = NS_TRUE1;
                  specPtr++;
                  continue;
              }
              if (status == TCL_OK0 && specPtr->dest == NULL((void*)0) && specPtr->arg != NULL((void*)0)) {
                  status = SetValue(interp, specPtr->key, specPtr->arg);
              }
              specPtr->dest = NULL((void*)0);
              specPtr++;
          }

      }
  }
  if (argsObj != objv[2]) {
      Tcl_DecrRefCount(argsObj)do { Tcl_Obj *_objPtr = (argsObj); if (_objPtr->refCount--
 <= 1) { TclFreeObj(_objPtr); } } while(0);
  }
  return status;
1347}

1349
1350/*
*----------------------------------------------------------------------
* SetSpecFromAny --
*
*      Attempt to convert a Tcl_Obj to ns:spec type.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1365static int
1366SetSpecFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr)
1367{
  Ns_ObjvSpec   *specPtr, *optSpec, *argSpec = NULL((void*)0);
  Tcl_Obj      **specv, **specPair, *defObjPtr;
  int            numSpecs, specLen, keyLen, i;

  if (Tcl_ListObjGetElements(interp, objPtr, &numSpecs, &specv) != TCL_OK0) {
      return TCL_ERROR1;
  }
  optSpec = ns_calloc((size_t) numSpecs + 2u, sizeof(Ns_ObjvSpec));
  specPtr = optSpec;

  for (i = 0; i < numSpecs; ++i) {
      const char *key;

      /*
       * Check for a default and extract the key.
       */

      if (Tcl_ListObjGetElements(interp, specv[i],
                                 &specLen, &specPair) != TCL_OK0) {
          FreeSpecs(optSpec);
          return TCL_ERROR1;
      }
      if (specLen == 0 || specLen > 2) {
          Ns_TclPrintfResult(interp, "wrong # fields in argument specifier \"%s\"",
                             Tcl_GetString(specv[i]));
          FreeSpecs(optSpec);
          return TCL_ERROR1;
      }
      key = Tcl_GetStringFromObj(specPair[0], &keyLen);
      if (specLen == 2) {
          defObjPtr = specPair[1];
      } else if (i + 1 == numSpecs && STREQ(key, "args")(((*(key)) == (*("args"))) && (strcmp((key),("args"))
 == 0))) {
          defObjPtr = Tcl_NewListObj(0, NULL((void*)0));
      } else {
          defObjPtr = NULL((void*)0);
      }

      /*
       * Examine the key: is this an option or an argument?
       */

      if (key[0] == '\0' || (key[0] == '-' && key[1] == '\0')) {
          Ns_TclPrintfResult(interp,
              "argument or option in position %d has no name", i);
          FreeSpecs(optSpec);
          return TCL_ERROR1;
      }
      if (key[0] == '-' && argSpec != NULL((void*)0)) {
          Ns_TclPrintfResult(interp, "expected argument \"%s\"", key);
          FreeSpecs(optSpec);
          return TCL_ERROR1;
      }
      if (key[0] != '-' && argSpec == NULL((void*)0)) {
          /*
           * Found the first non-option.
           */
          argSpec = ++specPtr;
      }

      /*
       * Arguments with default values must have their keys
       * prepended with '?' for the run time parser. Tcl 'args' are
       * always optional.
       */

      if ((key[0] != '-' && defObjPtr != NULL((void*)0))
          || (i + 1 == numSpecs && STREQ(key, "args")(((*(key)) == (*("args"))) && (strcmp((key),("args"))
 == 0)))) {
          char *rewrittenKey  = ns_malloc((size_t)keyLen + 2u);

          *rewrittenKey = '?';
          memcpy(rewrittenKey + 1, key, (size_t)keyLen + 1u);
          specPtr->key = rewrittenKey;
      } else {
          specPtr->key = ns_strdup(key);
      }

      if (defObjPtr != NULL((void*)0)) {
          Tcl_IncrRefCount(defObjPtr)++(defObjPtr)->refCount;
          specPtr->arg = defObjPtr;
      }
      if (STREQ(key, "--")(((*(key)) == (*("--"))) && (strcmp((key),("--")) == 0
))) {
          specPtr->proc = Ns_ObjvBreak;
      } else if (i + 1 == numSpecs && STREQ(key, "args")(((*(key)) == (*("args"))) && (strcmp((key),("args"))
 == 0))) {
          specPtr->proc = ObjvTclArgs;
      } else {
          specPtr->proc = ObjvTcl;
      }
      specPtr++;
  }
  if (argSpec == NULL((void*)0)) {
      argSpec = specPtr;
  }
  Ns_TclSetTwoPtrValue(objPtr, &specType, optSpec, argSpec);

  return TCL_OK0;
1463}

1465
1466/*
*----------------------------------------------------------------------
* FreeSpecs --
*
*     Free array of opt and arg specs.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

1481static void
1482FreeSpecs(Ns_ObjvSpec *specPtr)
1483{
  Ns_ObjvSpec  *saveSpec = specPtr;
  bool_Bool          doneOpts = NS_FALSE0;

  NS_NONNULL_ASSERT(specPtr != NULL)((void) (0));

  for (;;) {
      if (specPtr->key == NULL((void*)0)) {
          if (doneOpts) {
              break;
          }
          doneOpts = NS_TRUE1;
          specPtr++;
          continue;
      }
      ns_free((char *)specPtr->key);
      if (specPtr->arg != NULL((void*)0)) {
          Tcl_DecrRefCount((Tcl_Obj *) specPtr->arg)do { Tcl_Obj *_objPtr = ((Tcl_Obj *) specPtr->arg); if (_objPtr
->refCount-- <= 1) { TclFreeObj(_objPtr); } } while(0);
      }
      specPtr++;
  }
  ns_free(saveSpec);
1505}

1507
1508/*
*----------------------------------------------------------------------
* FreeSpecObj --
*
*     This procedure is called to delete the internal rep of a
*     ns:spec Tcl_Obj.
*
* Results:
*      None.
*
* Side effects:
*      The internal representation of the given object is deleted.
*
*----------------------------------------------------------------------
*/

1524static void
1525FreeSpecObj(Tcl_Obj *objPtr)
1526{
  Ns_ObjvSpec *optSpec;

  optSpec = objPtr->internalRep.twoPtrValue.ptr1;
  FreeSpecs(optSpec);

  objPtr->internalRep.twoPtrValue.ptr1 = NULL((void*)0);
  objPtr->internalRep.twoPtrValue.ptr2 = NULL((void*)0);
1534}

1536
1537/*
*----------------------------------------------------------------------
* UpdateStringOfSpec --
*
*     This procedure is called to convert a Tcl_Obj from
*     ns:spec internal form to its string form.
*
* Results:
*      None.
*
* Side effects:
*      The string representation of the object is updated.
*
*----------------------------------------------------------------------
*/

1553static void
1554UpdateStringOfSpec(Tcl_Obj *objPtr)
1555{
  const Ns_ObjvSpec *specPtr;
  Tcl_Obj           *defaultObj;
  Tcl_DString        ds;
  bool_Bool               doneOpts = NS_FALSE0;

  Tcl_DStringInit(&ds);
  Tcl_DStringStartSublist(&ds);
  specPtr = (Ns_ObjvSpec *) objPtr->internalRep.twoPtrValue.ptr1;
  for (;;) {
      if (specPtr->key == NULL((void*)0)) {
          if (doneOpts) {
              break;
          }
          doneOpts = NS_TRUE1;
          specPtr++;
          continue;
      }
      if (specPtr->arg != NULL((void*)0)) {
          defaultObj = (Tcl_Obj *) specPtr->arg;
          Tcl_DStringStartSublist(&ds);
          Tcl_DStringAppendElement(&ds, specPtr->key);
          Tcl_DStringAppendElement(&ds, Tcl_GetString(defaultObj));
          Tcl_DStringEndSublist(&ds);
      } else {
          Tcl_DStringAppendElement(&ds, specPtr->key);
      }
      specPtr++;
  }
  Tcl_DStringEndSublist(&ds);
  Ns_TclSetStringRep(objPtr, ds.string, ds.length);
  Tcl_DStringFree(&ds);
1587}

1589
1590/*
*----------------------------------------------------------------------
* DupSpec --
*
*     This procedure is called to copy the internal rep of a
*     ns:spec Tcl_Obj to another object.
*
* Results:
*      None.
*
* Side effects:
*      The internal representation of the target object is updated
*      and the type is set.
*
*----------------------------------------------------------------------
*/

1607static void
1608DupSpec(Tcl_Obj *srcObj, Tcl_Obj *dupObj)
1609{
  Ns_ObjvSpec  *oldOptSpec = srcObj->internalRep.twoPtrValue.ptr1;
  Ns_ObjvSpec  *oldArgSpec = srcObj->internalRep.twoPtrValue.ptr2;
  Ns_ObjvSpec  *optSpec, *argSpec, *specPtr;
  size_t        numSpecs = 2u;

  for (specPtr = oldOptSpec; specPtr->key != NULL((void*)0); specPtr++) {
      numSpecs++;
  }
  for (specPtr = oldArgSpec; specPtr->key != NULL((void*)0); specPtr++) {
      numSpecs++;
  }

  optSpec = ns_malloc(numSpecs * sizeof(Ns_ObjvSpec));
  memcpy(optSpec, oldOptSpec, numSpecs * sizeof(Ns_ObjvSpec));

  specPtr = optSpec;
  argSpec = NULL((void*)0);
  for (;;) {
      if (specPtr->key == NULL((void*)0)) {
          if (argSpec != NULL((void*)0)) {
              break;
          }
          argSpec = ++specPtr;
          continue;
      }
      specPtr->key = ns_strdup(specPtr->key);
      if (specPtr->arg != NULL((void*)0)) {
          Tcl_IncrRefCount((Tcl_Obj *) specPtr->arg)++((Tcl_Obj *) specPtr->arg)->refCount;
      }
      specPtr++;
  }
  Ns_TclSetTwoPtrValue(dupObj, &specType, optSpec, argSpec);
1642}

1644
1645/*
*----------------------------------------------------------------------
*
* ObjvTcl --
*
*      Consume exactly one argument, setting it as the value of a
*      variable named after the key in the given interp.
*
* Results:
*      TCL_OK or TCL_ERROR.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

1662static int
1663ObjvTcl(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr, Tcl_Obj *const* objv)
1664{
  int result;

  if (likely(*objcPtr > 0)(__builtin_expect((*objcPtr > 0), 1))) {
      result = SetValue(interp, spec->key, objv[0]);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          *objcPtr -= 1;
          spec->dest = VALUE_SUPPLIED(((void *)(intptr_t)(1)));
      }
  } else {
      Ns_TclPrintfResult(interp, "missing argument to %s", spec->key);
      result = TCL_ERROR1;
  }

  return result;
1679}

1681
1682/*
*----------------------------------------------------------------------
*
* ObjvTclArgs --
*
*      Consume all remaining args and reset the local variable "args"
*      in the given interp to contain them.
*
* Results:
*      TCL_OK and objcPtr set to 0, or TCL_ERROR.
*
* Side effects:
*          Value of existing Tcl variable "args" overwritten.
*
*----------------------------------------------------------------------
*/

1699static int
1700ObjvTclArgs(Ns_ObjvSpec *spec, Tcl_Interp *interp, int *objcPtr, Tcl_Obj *const* objv)
1701{
  Tcl_Obj  *listObj;
  int       result;

  listObj = Tcl_NewListObj(*objcPtr, objv);
  if (listObj == NULL((void*)0)) {
1
Assuming 'listObj' is not equal to NULL→
2
←
Taking false branch→
      result = TCL_ERROR1;
  } else {
      if (Tcl_SetVar2Ex(interp, "args", NULL((void*)0), listObj,
3
←
Assuming the condition is false→
4
←
Taking false branch→
                        TCL_LEAVE_ERR_MSG0x200) == NULL((void*)0)) {
          result = TCL_ERROR1;
      } else {
          *objcPtr = 0;
          spec->dest = VALUE_SUPPLIED(((void *)(intptr_t)(1)));
5
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
          result = TCL_OK0;
      }
  }

  return result;
1720}

1722
1723/*
*----------------------------------------------------------------------
*
* SetValue --
*
*      Strip any leading "-" or "?" from the key and set a variable
*      with the resulting name.  If value starts with "[" and ends
*      with "]" then evaluate Tcl script and assign result to the
*      variable.
*
* Results:
*      Tcl result code.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

1742static int
1743SetValue(Tcl_Interp *interp, const char *key, Tcl_Obj *valueObj)
1744{
  size_t      len;
  const char *value;
  int         result = TCL_OK0;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(key != NULL)((void) (0));
  NS_NONNULL_ASSERT(valueObj != NULL)((void) (0));

  value = Tcl_GetString(valueObj);

  if (key[0] == '-' || key[0] == '?') {
      key++;
  }

  len = strlen(value);
  if (value[0] == '[' && value[len - 1u] == ']') {
      value++;
      len -= 2u;

      result = Tcl_EvalEx(interp, value, (int)len, 0);
      if (result == TCL_OK0) {
          valueObj = Tcl_GetObjResult(interp);
      }
  }

  if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
      if (Tcl_SetVar2Ex(interp, key, NULL((void*)0), valueObj,
                        TCL_LEAVE_ERR_MSG0x200) == NULL((void*)0)) {
          result = TCL_ERROR1;
      } else {
          Tcl_ResetResult(interp);
      }
  }
  return result;
1779}

1781
1782/*
*----------------------------------------------------------------------
*
* WrongNumArgs --
*
*          Leave a usage message in the interpreters result.
*
* Results:
*          None.
*
* Side effects:
*          None.
*
*----------------------------------------------------------------------
*/

1798static void AppendRange(Ns_DStringTcl_DString *dsPtr, const Ns_ObjvValueRange *r)
1799{
  if (r->minValue == LLONG_MIN(-9223372036854775807LL -1LL)) {
      Tcl_DStringAppend(dsPtr, "[MIN,", 5);
  } else {
      Ns_DStringPrintf(dsPtr, "[%" TCL_LL_MODIFIER"l" "d,", r->minValue);
  }

  if (r->maxValue == LLONG_MAX9223372036854775807LL) {
      Tcl_DStringAppend(dsPtr, "MAX]", 4);
  } else {
      Ns_DStringPrintf(dsPtr, "%" TCL_LL_MODIFIER"l" "d]", r->maxValue);
  }
1811}

1813static void
1814WrongNumArgs(const Ns_ObjvSpec *optSpec, Ns_ObjvSpec *argSpec, Tcl_Interp *interp,
           int objc, Tcl_Obj *const* objv)
1816{
  const Ns_ObjvSpec *specPtr;
  Ns_DStringTcl_DString         ds;

  Ns_DStringInitTcl_DStringInit(&ds);
  if (optSpec != NULL((void*)0)) {
      for (specPtr = optSpec; specPtr->key != NULL((void*)0); ++specPtr) {
          if (STREQ(specPtr->key, "--")(((*(specPtr->key)) == (*("--"))) && (strcmp((specPtr
->key),("--")) == 0))) {
              Ns_DStringAppend(&ds, "?--? ")Tcl_DStringAppend((&ds), ("?--? "), -1);
          } else if (specPtr->proc == Ns_ObjvBool && specPtr->arg != NULL((void*)0)) {
              Ns_DStringPrintf(&ds, "?%s? ", specPtr->key);
          } else {
              const char *p = specPtr->key;
              if (*specPtr->key == '-') {
                  ++p;
              }
              Ns_DStringPrintf(&ds, "?%s %s", specPtr->key, p);

              if ((specPtr->proc == Ns_ObjvInt
                   || specPtr->proc == Ns_ObjvLong
                   || specPtr->proc == Ns_ObjvWideInt
                   ) && specPtr->arg != NULL((void*)0)) {
                  AppendRange(&ds, specPtr->arg);
              }
              Tcl_DStringAppend(&ds, "? ", 2);
          }
      }
  }
  if (argSpec != NULL((void*)0)) {
      for (specPtr = argSpec; specPtr->key != NULL((void*)0); ++specPtr) {
          Tcl_DStringAppend(&ds, specPtr->key, -1);

          if ((specPtr->proc == Ns_ObjvInt
               || specPtr->proc == Ns_ObjvLong
               || specPtr->proc == Ns_ObjvWideInt
               ) && specPtr->arg != NULL((void*)0)) {
              AppendRange(&ds, specPtr->arg);
          }
          if (*specPtr->key == '?') {
              Tcl_DStringAppend(&ds, "?", 1);
          }
          Tcl_DStringAppend(&ds, " ", 1);
      }
  }
  if (ds.length > 0) {
      Ns_DStringSetLengthTcl_DStringSetLength(&ds, ds.length - 1);
      Tcl_WrongNumArgs(interp, objc, objv, ds.string);
  } else {
      Tcl_WrongNumArgs(interp, objc, objv, NULL((void*)0));
  }

  Ns_DStringFreeTcl_DStringFree(&ds);
1868}

1870/*
*----------------------------------------------------------------------
*
* Ns_SubcmdObjv --
*
*      Call subcommand based on the provided name and associated
*      functions.
*
* Results:
*      Tcl result code.
*
* Side effects:
*      Depends on the Ns_ObjvTypeProcs which run.
*
*----------------------------------------------------------------------
*/
1886int
1887Ns_SubcmdObjv(const Ns_SubCmdSpec *subcmdSpec, ClientData clientData, Tcl_Interp *interp,
            int objc, Tcl_Obj *const* objv)
1889{
  int opt = 0, result;

  if (objc < 2) {
      /*
       * The command was called without selector for the
       * subcmd. With out own machinery (as used in
       * GetOptIndexSubcmdSpec()) we could list the available
       * options, but that is just used for shared objects.
       */
      Tcl_WrongNumArgs(interp, 1, objv, "command ?args?");
      result = TCL_ERROR1;
  } else {
      Tcl_Obj *selectorObj = objv[1];
      /*
       * If the obj is shared, don't trust its internal representation.
       */
      result = Tcl_IsShared(selectorObj)((selectorObj)->refCount > 1)
          ? GetOptIndexSubcmdSpec(interp, selectorObj, "subcmd", subcmdSpec, &opt)
          : Tcl_GetIndexFromObjStruct(interp, objv[1], subcmdSpec, sizeof(Ns_SubCmdSpec), "subcmd",
                                      TCL_EXACT1, &opt);
      if (likely(result == TCL_OK)(__builtin_expect((result == 0), 1))) {
          result = (*subcmdSpec[opt].proc)(clientData, interp, objc, objv);
      }
  }
  return result;
1915}

1917
1918/*
*----------------------------------------------------------------------
*
* GetOptIndexSubcmdSpec --
*
*      Process options similar to Tcl_GetIndexFromObj() but don't
*      cache results as internal reps.
*
*      Background: see GetOptIndexObjvSpec()
*
* Results:
*      Tcl result
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/
1936static int
1937GetOptIndexSubcmdSpec(Tcl_Interp *interp, Tcl_Obj *obj, const char *msg, const Ns_SubCmdSpec *tablePtr, int *idxPtr)
1938{
  const Ns_SubCmdSpec *entryPtr;
  const char          *key;
  int                  idx, result = TCL_ERROR1;

  NS_NONNULL_ASSERT(interp != NULL)((void) (0));
  NS_NONNULL_ASSERT(obj != NULL)((void) (0));
  NS_NONNULL_ASSERT(msg != NULL)((void) (0));
  NS_NONNULL_ASSERT(tablePtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(idxPtr != NULL)((void) (0));

  key = Tcl_GetString(obj);

  for (entryPtr = tablePtr, idx = 0; entryPtr->key != NULL((void*)0);  entryPtr++, idx++) {
      const char *p1, *p2;

      for (p1 = key, p2 = entryPtr->key; *p1 == *p2; p1++, p2++) {
          if (*p1 == '\0') {
              /*
               * Both words are at their ends. Match is successful.
               */
              *idxPtr = idx;
              result = TCL_OK0;
              break;
          }
      }
      if (*p1 == '\0') {
          /*
           * The value is an abbreviation for this entry.
           */
          break;
      }
  }

  if (result == TCL_ERROR1) {
      Tcl_Obj *resultPtr;

      /*
       * Produce a fancy error message.
       */
      resultPtr = Tcl_NewObj();
      Tcl_AppendStringsToObj(resultPtr, "bad ", msg, " \"", key, (char *)0L);

      entryPtr = tablePtr;
      if (entryPtr->key == NULL((void*)0)) {
          /*
           * The table is empty
           */
          Tcl_AppendStringsToObj(resultPtr, "\": no valid options", (char *)0L);
      } else {
          int count = 0;
          /*
           * The table has keys
           */
          Tcl_AppendStringsToObj(resultPtr, "\": must be ", entryPtr->key, (char *)0L);
          entryPtr++;
          while (entryPtr->key != NULL((void*)0)) {
              if ((entryPtr+1)->key == NULL((void*)0)) {
                  Tcl_AppendStringsToObj(resultPtr, (count > 0 ? "," : NS_EMPTY_STRING),
                                         " or ", entryPtr->key, (char *)0L);
              } else {
                  Tcl_AppendStringsToObj(resultPtr, ", ", entryPtr->key, (char *)0L);
                  count++;
              }
              entryPtr++;
          }
      }
      Tcl_SetObjResult(interp, resultPtr);
      Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "INDEX", msg, key, (char *)0L);
  }

 return result;
2010}


2013/*
* Local Variables:
* mode: c
* c-basic-offset: 4
* fill-column: 70
* indent-tabs-mode: nil
* End:
*/