tclImpl (
    Tcl_Interp *interp,
    void *constraintData,
    char *text
    )
{
    tclTCData *tcdata = constraintData;
    int result, boolVal;

    tcdata->evalStub[tcdata->nrArg-1] = Tcl_NewStringObj(text, -1);
    Tcl_IncrRefCount (tcdata->evalStub[tcdata->nrArg-1]);
    tcdata->sdata->currentEvals++;
    result = Tcl_EvalObjv (interp, tcdata->nrArg, tcdata->evalStub,
                           TCL_EVAL_GLOBAL);
    tcdata->sdata->currentEvals--;
    Tcl_DecrRefCount (tcdata->evalStub[tcdata->nrArg-1]);
    if (result != TCL_OK) {
        tcdata->sdata->evalError = 1;
        return 0;
    }
    result = Tcl_GetBooleanFromObj (interp, Tcl_GetObjResult (interp), &boolVal);
    if (result != TCL_OK) {
        return 0;
    }
    if (boolVal) {
        return 1;
    } 
    return 0;
}

static int
tclTCObjCmd (

    ClientData UNUSED(dummy),
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[]
    )
{
    CHandlerSet     *handlerSet;
    int              methodIndex, result, boolVal;
    tdomCmdReadInfo *info;
    TclGenExpatInfo *expat;
    Tcl_Obj         *newObjName = NULL;

    static const char *tdomMethods[] = {
        "enable", "getdoc",
        "setStoreLineColumn",

        info = CHandlerSetGetUserData (interp, objv[1], "tdom");
        if (!info) {
            Tcl_SetResult (interp, "parser object isn't tdom enabled.", NULL);
            return TCL_ERROR;
        }
        Tcl_SetIntObj (Tcl_GetObjResult (interp), info->storeLineColumn);
        if (objc == 4) {
            if (Tcl_GetBooleanFromObj (interp, objv[3], &boolVal) != TCL_OK) {
                return TCL_ERROR;
            }
            info->storeLineColumn = boolVal;
        }
        info->tdomStatus = 1;
        break;
        
    case m_remove:
        result = CHandlerSetRemove (interp, objv[1], "tdom");
        if (result == 2) {

        }
        info = handlerSet->userData;
        if (!info) {
            Tcl_SetResult (interp, "parser object isn't tdom enabled.", NULL);
            return TCL_ERROR;
        }
        Tcl_SetIntObj (Tcl_GetObjResult (interp), info->ignoreWhiteSpaces);
        if (Tcl_GetBooleanFromObj (interp, objv[3], &boolVal) != TCL_OK) {
            return TCL_ERROR;
        }
        info->ignoreWhiteSpaces = !boolVal;
        handlerSet->ignoreWhiteCDATAs = !boolVal;
        info->tdomStatus = 1;
        break;

    case m_keepCDATA:
        if (objc != 4) {
            Tcl_SetResult (interp, "wrong # of args for method keepCDATA.",
                           NULL);
            return TCL_ERROR;
        }
        handlerSet = CHandlerSetGet (interp, objv[1], "tdom");
        if (!handlerSet) {
            Tcl_SetResult (interp, "parser object isn't tdom enabled.", NULL);
            return TCL_ERROR;
        }
        info = handlerSet->userData;
        if (!info) {
            Tcl_SetResult (interp, "parser object isn't tdom enabled.", NULL);
            return TCL_ERROR;
        }
        if (Tcl_GetBooleanFromObj (interp, objv[3], &boolVal) != TCL_OK) {
            return TCL_ERROR;
        }
        if (boolVal) {
            handlerSet->startCdataSectionCommand = tdom_startCDATA;
            handlerSet->endCdataSectionCommand = endCDATA;
        } else {
            handlerSet->startCdataSectionCommand = NULL;
            handlerSet->endCdataSectionCommand = NULL;
        }
        info->tdomStatus = 1;

            return TCL_ERROR;
        }
        info = handlerSet->userData;
        if (!info) {
            Tcl_SetResult (interp, "parser object isn't tdom enabled.", NULL);
            return TCL_ERROR;
        }
        if (Tcl_GetBooleanFromObj (interp, objv[3], &boolVal) != TCL_OK) {
            return TCL_ERROR;
        }
        expat = GetExpatInfo (interp, objv[1]);
        expat->keepTextStart = boolVal;
        expat->cdataStartLine = 0;
        break;
        
    case m_ignorexmlns:
        info = CHandlerSetGetUserData (interp, objv[1], "tdom");
        if (!info) {
            Tcl_SetResult (interp, "parser object isn't tdom enabled.", NULL);
            return TCL_ERROR;
        }
        Tcl_SetIntObj (Tcl_GetObjResult (interp), info->ignorexmlns);
        if (objc == 4) {
            if (Tcl_GetBooleanFromObj (interp, objv[3], &boolVal) != TCL_OK) {
                return TCL_ERROR;
            }
            info->ignorexmlns = boolVal;
        }
        info->tdomStatus = 1;
        break;

    }

    return TCL_OK;
}

    int          outputFlags,
    int          level,
    int          inside
    )
{
    domTextNode *textNode;
    Tcl_Obj *valueObj;
    int boolVal;
    
    switch (node->nodeType) {
    case TEXT_NODE:
        if (inside == JSON_OBJECT) {
            /* We're inside a JSON object. A text node can not be
             * meaningful interpreted as member of an object. Ignore
             * the node */

            break;
        case JSON_FALSE:
            writeChars(jstring, channel, "false",5);
            break;
        case JSON_BOOLEAN:
            valueObj = Tcl_NewStringObj (textNode->nodeValue,
                                         textNode->valueLength);
            if (Tcl_GetBooleanFromObj(NULL, valueObj, &boolVal) == TCL_OK) {
                if (boolVal) {
                    writeChars(jstring, channel, "true",4);
                } else {
                    writeChars(jstring, channel, "false",5);
                }
                Tcl_DecrRefCount (valueObj);
                break;
            }

}

typedef struct 
{
    Tcl_Obj  *object;
    Tcl_Obj  *array;
    Tcl_Obj  *null;
    Tcl_Obj  *trueVal;
    Tcl_Obj  *falseVal;
    Tcl_Obj  *number;
    Tcl_Obj  *string;
} asTypedListTypes;


/*----------------------------------------------------------------------------
|   tcldom_treeAsTypedList

    } else {
        /* Text node */
        switch (node->info) {
        case JSON_NULL:
            Tcl_ListObjAppendElement (NULL, resultObj, c->null);
            break;
        case JSON_TRUE:
            Tcl_ListObjAppendElement (NULL, resultObj, c->trueVal);
            break;
        case JSON_FALSE:
            Tcl_ListObjAppendElement (NULL, resultObj, c->falseVal);
            break;
        case JSON_NUMBER:
            textNode = (domTextNode *)node;
            if (isJSONNumber (textNode->nodeValue, textNode->valueLength)) {
                Tcl_ListObjAppendElement(NULL, resultObj, c->number);
                Tcl_ListObjAppendElement(
                    NULL, resultObj, Tcl_NewStringObj(textNode->nodeValue,

        Tcl_ResetResult (interp);
        return;
    }

    c.object = Tcl_NewStringObj ("OBJECT", 6);
    c.array = Tcl_NewStringObj ("ARRAY", 5);
    c.null = Tcl_NewStringObj ("NULL", 4);
    c.trueVal = Tcl_NewStringObj ("TRUE", 4);
    c.falseVal = Tcl_NewStringObj ("FALSE", 5);
    c.number = Tcl_NewStringObj ("NUMBER", 6);
    c.string = Tcl_NewStringObj ("STRING", 6);

    Tcl_IncrRefCount (c.object);
    Tcl_IncrRefCount (c.array);
    Tcl_IncrRefCount (c.null);
    Tcl_IncrRefCount (c.trueVal);
    Tcl_IncrRefCount (c.falseVal);
    Tcl_IncrRefCount (c.number);
    Tcl_IncrRefCount (c.string);

    if (node->nodeType == ELEMENT_NODE
        && node->info == 0
        && node->firstChild->nodeType == TEXT_NODE) {
        /* Either a value only json document or a OBJECT propertiy
         * element node.*/ 
        node = node->firstChild;
    }
    
    Tcl_SetObjResult (interp, 
                      tcldom_treeAsTypedListWorker (node, &c));

    Tcl_DecrRefCount (c.object);
    Tcl_DecrRefCount (c.array);
    Tcl_DecrRefCount (c.null);
    Tcl_DecrRefCount (c.trueVal);
    Tcl_DecrRefCount (c.falseVal);
    Tcl_DecrRefCount (c.number);
    Tcl_DecrRefCount (c.string);
}

/*----------------------------------------------------------------------------
|   findBaseURI
|

    Tcl_Interp *interp,
    int         objc,
    Tcl_Obj    *const objv[]
)
{
    char          *channelId, prefix[MAX_PREFIX_LEN];
    const char    *localName;
    int            indent, mode, boolVal;
    int            outputFlags = 0;
    int            optionIndex, cdataChild;
    Tcl_Obj       *resultPtr, *encString = NULL;
    Tcl_Channel    chan = (Tcl_Channel) NULL;
    Tcl_HashEntry *h;
    Tcl_DString    dStr;
    int            indentAttrs = -1;

                goto cleanup;
            }
            if (objc < 4) {
                SetResult("-doctypeDeclaration must have a boolean value "
                          "as argument");
                goto cleanup;
            }
            if (Tcl_GetBooleanFromObj(interp, objv[3], &boolVal)
                != TCL_OK) {
                goto cleanup;
            }
            if (boolVal) outputFlags |= SERIALIZE_DOCTYPE_DECLARATION;
            objc -= 2;
            objv += 2;
            break;

        case m_xmlDeclaration:
            if (objc < 4) {
                SetResult("-xmlDeclaration must have a boolean value "
                          "as argument");
                goto cleanup;
            }
            if (Tcl_GetBooleanFromObj(interp, objv[3], &boolVal)
                != TCL_OK) {
                goto cleanup;
            }
            if (boolVal) outputFlags |= SERIALIZE_XML_DECLARATION;
            objc -= 2;
            objv += 2;
            break;

        case m_encString:
            if (objc < 4) {
                SetResult("-encString must have a string "

    char         tmp[200], prefix[MAX_PREFIX_LEN], *method, *nodeName,
                 *str, *attr_name, *attr_val, *filter;
    const char  *localName, *uri, *nsStr;
    int          result, methodIndex, i;
    domLength    length;
    XML_Size     line, column;
    XML_Index    byteIndex;
    int          nsIndex, boolVal, hnew, legacy, jsonType;
    Tcl_Obj     *namePtr, *resultPtr;
    Tcl_Obj     *mobjv[MAX_REWRITE_ARGS], *storedErrMsg;
    Tcl_CmdInfo  cmdInfo;
    Tcl_HashEntry *h;

    static const char *nodeMethods[] = {
        "firstChild",      "nextSibling",    "getAttribute",    "nodeName",

            if (node->nodeType != TEXT_NODE) {
                SetResult("not a TEXT_NODE!");
                return TCL_ERROR;
            }
            SetIntResult(
                (((node->nodeFlags & DISABLE_OUTPUT_ESCAPING) == 0) ? 0 : 1));
            if (objc == 3) {
                if (Tcl_GetBooleanFromObj(interp, objv[2], &boolVal) != TCL_OK) {
                    return TCL_ERROR;
                }
                if (boolVal) {
                    node->nodeFlags |= DISABLE_OUTPUT_ESCAPING;
                } else {
                    node->nodeFlags &= (~DISABLE_OUTPUT_ESCAPING);
                }
            }
            break;

            str = xpathGetStringValue(node, &length);
            Tcl_SetStringObj(Tcl_GetObjResult(interp), str, length);
            FREE (str);
            return TCL_OK;

        case m_normalize:
            CheckArgs (2,3,2, "?-forXPath?");
            boolVal = 0;
            if (objc == 3) {
                if (strcmp (Tcl_GetString(objv[2]), "-forXPath") == 0) {
                    boolVal = 1;
                } else {
                    SetResult("unknown option! Options: ?-forXPath?");
                    return TCL_ERROR;
                }
            }
            domNormalize (node, boolVal, tcldom_deleteNode, interp);
            return TCL_OK;

        case m_jsonType:
            CheckArgs (2,3,2, "?jsonType?");
            if (node->nodeType != ELEMENT_NODE
                && node->nodeType != TEXT_NODE) {
                SetResult("Only element and text nodes may have a JSON type.");

{
    GetTcldomDATA;

    domDeleteInfo       * dinfo;
    domDocument         * doc;
    char                * method, *tag, *data, *target, *uri, tmp[100];
    char                * str, *docName, *errMsg;
    int                   methodIndex, result, i, nsIndex, forXPath, boolVal;
    int                   setDocumentElement = 0, restoreDomCreateCmdMode = 0;
    domLength             data_length, target_length;
    domNode             * n;
    Tcl_CmdInfo           cmdInfo;
    Tcl_Obj             * mobjv[MAX_REWRITE_ARGS], *storedErrMsg;

    static const char *docMethods[] = {

            CheckArgs(2,3,2, "?boolean?");
            if (doc->nodeFlags & OUTPUT_DEFAULT_INDENT) {
                SetBooleanResult (1);
            } else {
                SetBooleanResult(0);
            }
            if (objc == 3) {
                if (Tcl_GetBooleanFromObj (interp, objv[2], &boolVal) != TCL_OK) {
                    return TCL_ERROR;
                }
                if (boolVal) {
                    doc->nodeFlags |= OUTPUT_DEFAULT_INDENT;
                } else {
                    doc->nodeFlags &= ~OUTPUT_DEFAULT_INDENT;
                }
            }
            return TCL_OK;
            

    Tcl_Obj    * const objv[]
)
{
    GetTcldomDATA;

    char        * method, tmp[300], *string, *option,
                 *replacement;
    int           methodIndex, result, i, boolVal, changed;
    domLength     repllen;
    Tcl_CmdInfo   cmdInfo;
    Tcl_Obj     * mobjv[MAX_REWRITE_ARGS], *newObj, *storedErrMsg;
    Tcl_DString   cleardString, escapedStr;

    static const char *domMethods[] = {
        "createDocument",  "createDocumentNS",   "createNodeCmd",

                return TCL_OK;
            }
            break;
#endif

        case m_setStoreLineColumn:
            if (objc == 3) {
                if (Tcl_GetBooleanFromObj(interp, objv[2], &boolVal) != TCL_OK) {
                    return TCL_ERROR;
                }
                TcldomDATA(storeLineColumn) = boolVal;
            }
            SetBooleanResult(TcldomDATA(storeLineColumn));
            return TCL_OK;

        case m_setNameCheck:
            if (objc == 3) {
                if (Tcl_GetBooleanFromObj(interp, objv[2], &boolVal) != TCL_OK) {
                    return TCL_ERROR;
                }
                TcldomDATA(dontCheckName) = !boolVal;
            }
            SetBooleanResult(!TcldomDATA(dontCheckName));
            return TCL_OK;
            
        case m_setTextCheck:
            if (objc == 3) {
                if (Tcl_GetBooleanFromObj(interp, objv[2], &boolVal) != TCL_OK) {
                    return TCL_ERROR;
                }
                TcldomDATA(dontCheckCharData) = !boolVal;
            }
            SetBooleanResult(!TcldomDATA(dontCheckCharData));
            return TCL_OK;
            
        case m_setObjectCommands:
            if (objc == 3) {
                if (Tcl_GetIndexFromObj (interp, objv[2], nodeModeValues,

      (char *) NULL
  };
  enum paramEntityParsingValues {
      EXPAT_PARAMENTITYPARSINGALWAYS,
      EXPAT_PARAMENTITYPARSINGNEVER,
      EXPAT_PARAMENTITYPARSINGNOTSTANDALONE
  };
  int optionIndex, value, boolVal;
  Tcl_Obj *const *objPtr = objv;
  Tcl_CmdInfo cmdInfo;
  int rc;
  domLength len;
  char *handlerSetName = NULL;
  TclHandlerSet *tmpTclHandlerSet, *activeTclHandlerSet = NULL;
  Tcl_UniChar uniChar;

              expat->activationThreshold = activationThreshold;
          }
#endif          
          break;
          
      case EXPAT_FINAL:			/* -final */

	if (Tcl_GetBooleanFromObj(interp, objPtr[1], &boolVal) != TCL_OK) {
            return TCL_ERROR;
	}

        expat->final = boolVal;
	break;

      case EXPAT_BASE:			/* -baseurl */

        if (expat->baseURI) {
            Tcl_DecrRefCount (expat->baseURI);
            expat->baseURI = NULL;

        if (activeTclHandlerSet->ignoreWhiteCDATAs) {
            expat->needWSCheck = 1;
        }
	break;

      case EXPAT_USEFOREIGNDTD:                /* -useForeignDTD */
        
        if (Tcl_GetBooleanFromObj (interp, objPtr[1], &boolVal) != TCL_OK) {
            return TCL_ERROR;
        }
        if (expat->parser) {
            /* Cannot be changed after parsing as started (which is
               kind of understandable). */
            if (XML_UseForeignDTD (expat->parser, (unsigned char)boolVal)
                != XML_ERROR_NONE) {
                expat->useForeignDTD = boolVal;
            }
        } else {
            expat->useForeignDTD = boolVal;
        }
        break;

      case EXPAT_COMMENTCMD:      /* -commentcommand */
	/* [email protected] */
        CheckDefaultTclHandlerSet;
	if (activeTclHandlerSet->commentCommand != NULL) {

                }
                tmpTclHandlerSet->nextHandlerSet = activeTclHandlerSet;
            }
        }
        break;

    case EXPAT_NOEXPAND:
        if (Tcl_GetBooleanFromObj (interp, objPtr[1], &boolVal) != TCL_OK) {
            return TCL_ERROR;
        }
        if (boolVal) {
            XML_SetDefaultHandler( expat->parser,
                                   TclGenExpatDefaultHandler);
        } else {
            XML_SetDefaultHandlerExpand( expat->parser,
                                         TclGenExpatDefaultHandler);
        }
        expat->noexpand = boolVal;
        break;

    case EXPAT_FASTCALL:
        if (Tcl_GetBooleanFromObj (interp, objPtr[1], &boolVal) != TCL_OK) {
            return TCL_ERROR;
        }
        CheckDefaultTclHandlerSet;
        activeTclHandlerSet->fastCall = boolVal;
        break;
                  
    case EXPAT_KEEPTEXTSTART:
        if (Tcl_GetBooleanFromObj(interp, objPtr[1], &boolVal) != TCL_OK) {
            return TCL_ERROR;
	}

        expat->keepTextStart = boolVal;
	break;

#ifndef TDOM_NO_SCHEMA
    case EXPAT_VALIDATECMD:
        schemacmd = Tcl_GetString (objv[1]);
        if (schemacmd[0] == '\0') {
            if (expat->sdata) {