Tcl_Interp *interp,
    Tcl_Obj *list,
    Tcl_Obj **typeValue
    )
{
    Tcl_Obj *symbol;
    char *s;
    domLength slen, llen;
    
    if (Tcl_ListObjIndex (interp, list, 0, &symbol) != TCL_OK) {
        return -1;
    }
    if (!symbol) {
        /* Empty lists are not allowed. */
        SetResult ("Empty list.");
        return -1;
    }
    Tcl_ListObjLength (interp, list, &llen);
    if (llen > 2) {
        SetResult ("Too much list elements.");
        return -1;
    }
    Tcl_ListObjIndex (interp, list, 1, typeValue);
    s = Tcl_GetStringFromObj (symbol, &slen);
    if (strcmp (s, "STRING") == 0) {
        if (*typeValue == NULL) {
            SetResult ("Missing value for STRING.");
            return -1;
        }
        return JSON_STRING;
    } else if (strcmp (s, "OBJECT") == 0) {
        if (*typeValue == NULL) {
            SetResult ("Missing value for OBJECT.");
            return -1;
        }
        return JSON_OBJECT;
    } else if (strcmp (s, "NUMBER") == 0) {
        if (*typeValue == NULL) {
            SetResult ("Missing value for NUMBER.");
            return -1;
        }
        s = Tcl_GetStringFromObj (*typeValue, &slen);
        if (!isJSONNumber (s, slen)) {
            SetResult ("Not a valid NUMBER value.");
            return -1;
        }
        return JSON_NUMBER;
    } else if (strcmp (s, "ARRAY") == 0) {
        if (*typeValue == NULL) {
            SetResult ("Missing value for ARRAY.");
            return -1;
        }
        return JSON_ARRAY;
    } else if (strcmp (s, "TRUE") == 0) {
        if (*typeValue != NULL) {
            SetResult ("No value expected for TRUE.");
            return -1;
        }
        return JSON_TRUE;
    } else if (strcmp (s, "FALSE") == 0) {
        if (*typeValue != NULL) {
            SetResult ("No value expected for FALSE.");
            return -1;
        }
        return JSON_FALSE;
    } else if (strcmp (s, "NULL") == 0) {
        if (*typeValue != NULL) {
            SetResult ("No value expected for NULL.");
            return -1;
        }
        return JSON_NULL;
    } else {
        SetResult3 ("Unkown symbol \"", s, "\".");
        return -1;
    }            
}

static void objectErrMsg (
    Tcl_Interp *interp,
    domNode *node
    ) 
{
    Tcl_Obj *msg;

    msg = Tcl_GetObjResult (interp);
    Tcl_IncrRefCount (msg);
    Tcl_ResetResult (interp);
    Tcl_AppendResult (interp, "object property \"", node->nodeName,
                      "\": ", Tcl_GetString (msg), (char *)NULL);
    Tcl_DecrRefCount (msg);
}

static void arrayErrMsg (
    Tcl_Interp *interp,
    domLength i
    ) 
{
    Tcl_Obj *msg;
    char buf[20];

    msg = Tcl_GetObjResult (interp);
    Tcl_IncrRefCount (msg);
    Tcl_ResetResult (interp);
    sprintf (buf, domLengthConversion, i + 1);
    Tcl_AppendResult (interp, "array element ", buf, ": ",
                      Tcl_GetString (msg), (char *) NULL);
    Tcl_DecrRefCount (msg);
}

static int
TypedList2DOMWorker (
    Tcl_Interp *interp,
    domNode *parent,
    Tcl_Obj *value
    )

    
    switch (parent->info) {
    case JSON_OBJECT:
        if (Tcl_ListObjLength (interp, value, &llen) != TCL_OK) {
            return TCL_ERROR;
        }
        if (llen % 2 != 0) {

            SetResult ("An OBJECT value must be a Tcl list with an even "
                       "number of elements.");

            return TCL_ERROR;
        }
        for (i = 0; i < llen; i += 2) {
            /* Since we loop over all elements every element is
             * present and there is no need to check property or
             * pvalue for NULL. */
            Tcl_ListObjIndex (interp, value, i, &property);
            Tcl_ListObjIndex (interp, value, i+1, &pvalue);
            pnode = domAppendNewElementNode (parent, Tcl_GetString (property),
                                             NULL);
            jsonType = getJSONTypeFromList (interp, pvalue, &pdetail);
            if (jsonType < 0) {
                objectErrMsg (interp, pnode);
                return TCL_ERROR;
            }
            if (jsonType < 3) {
                /* JSON_OBJECT or JSON_ARRAY */
                pnode->info = jsonType;
                if (TypedList2DOMWorker (interp, pnode, pdetail) != TCL_OK) {
                    objectErrMsg (interp, pnode);
                    return TCL_ERROR;
                }
            } else {
                /* The other json types are represented by a text node.*/
                switch (jsonType) {
                case JSON_NUMBER:
                case JSON_STRING:

        if (Tcl_ListObjLength (interp, value, &llen) != TCL_OK) {
            return TCL_ERROR;
        }
        for (i = 0; i < llen; i++) {
            Tcl_ListObjIndex (interp, value, i, &aelm);
            jsonType = getJSONTypeFromList (interp, aelm, &adetail);
            if (jsonType < 0) {
                arrayErrMsg (interp, i);
                return TCL_ERROR;
            }
            switch (jsonType) {
            case JSON_OBJECT:
                container = domAppendNewElementNode (parent,
                                                     JSON_OBJECT_CONTAINER,
                                                     NULL);
                container->info = JSON_OBJECT;                
                if (TypedList2DOMWorker (interp, container, adetail) != TCL_OK) {
                    arrayErrMsg (interp, i);
                    return TCL_ERROR;
                }
                break;
            case JSON_ARRAY:
                container = domAppendNewElementNode (parent,
                                                     JSON_ARRAY_CONTAINER,
                                                     NULL);
                container->info = JSON_ARRAY;                
                if (TypedList2DOMWorker (interp, container, adetail) != TCL_OK) {
                    arrayErrMsg (interp, i);
                    return TCL_ERROR;
                }
                break;
            default:
                /* The other json types are represented by a text node.*/
                switch (jsonType) {
                case JSON_NUMBER:
                case JSON_STRING:
                    str = Tcl_GetStringFromObj (adetail, &strl);

    Tcl_Interp *interp,
    Tcl_Obj *typedList
    )
{
    domDocument *doc;
    domNode *rootNode;
    domTextNode *textNode;
    Tcl_Obj *value, *msg;
    char *str;
    domLength strl;
    int jsonType;

    jsonType = getJSONTypeFromList (interp, typedList, &value);
    if (jsonType < 0) {
        msg = Tcl_GetObjResult (interp);
        Tcl_IncrRefCount (msg);
        Tcl_ResetResult (interp);
        Tcl_AppendResult (interp, "Invalid typed list format: ",
                          Tcl_GetString (msg), (char *) NULL);
        Tcl_DecrRefCount (msg);
        return NULL;
    }
    doc  = domCreateDoc (NULL, 0);
    rootNode = doc->rootNode;
    if (jsonType < 3) {
        /* JSON_OBJECT or JSON_ARRAY */
        rootNode->info = jsonType;
        if (TypedList2DOMWorker (interp, rootNode, value) != TCL_OK) {
            msg = Tcl_GetObjResult (interp);
            Tcl_IncrRefCount (msg);
            domFreeDocument(doc, NULL, interp);
            Tcl_ResetResult (interp);
            Tcl_AppendResult (interp, "Invalid typed list format: ",
                              Tcl_GetString (msg), (char *) NULL);
            Tcl_DecrRefCount (msg);
            return NULL;
        }
    } else {
        /* The other json types are represented by a text node.*/
        if (jsonType > 5) {
            /* JSON_STRING or JSON_NUMBER */
            str = Tcl_GetStringFromObj (value, &strl);
        } else {
            str = "";
            strl = 0;
        }
        textNode = domNewTextNode (doc, str, strl, TEXT_NODE);
        textNode->info = jsonType;
        domAppendChild (rootNode, (domNode *) textNode);
    }
    return doc;



}

domDocument *
JSON_Parse (
    char *json,    /* Complete text of the json string being parsed */
    char *documentElement, /* name of the root element, may be NULL */
    int   maxnesting,

testConstraint needExpand 1
if {$tcl_version < 8.5} {
    testConstraint needExpand 0
}
# See below the comment in proc dom for explanation
if {[info commands _dom] eq ""} {
    testConstraint nonetest 1
} else {
    testConstraint nonetest 0
}
namespace eval nodeCmds {
    dom createNodeCmd elementNode e1
    dom createNodeCmd -jsonType ARRAY elementNode jae1
    dom createNodeCmd elementNode e2
    dom createNodeCmd commentNode c
    dom createNodeCmd textNode    t

test json-1.8 {Parse JSON - true, false, null} {
    set doc [dom parse -json -jsonroot "JSONObject" {{"a":true,"b":false,"c":null,"d":"true","e":""}}]
    set result [$doc asXML -indent none]
    $doc delete
    set result
} {<JSONObject><a>true</a><b>false</b><c>null</c><d>true</d><e></e></JSONObject>}

test json-1.9 {JSON syntax error} {nonetest} {
    set result [catch {dom parse -json {{"a" "a value"}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 5
"{"a" " <--Error-- a value"}"}}

test json-1.10 {JSON syntax error} {nonetest} {
    set result [catch {dom parse -json {{"a":00.23}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 6
"{"a":00 <--Error-- .23}"}}

test json-1.11 {JSON syntax error} {nonetest} {
    set result [catch {dom parse -json {{"a":-00.23}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 7
"{"a":-00 <--Error-- .23}"}}

test json-1.12 {JSON syntax error} {nonetest} {
    set result [catch {dom parse -json {{"a":.23}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 5
"{"a":. <--Error-- 23}"}}

test json-1.13 {JSON syntax error} {nonetest} {
    set result [catch {dom parse -json {{"a":-.23}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 6
"{"a":-. <--Error-- 23}"}}

test json-1.14 {JSON syntax error} {nonetest} {
    set result [catch {dom parse -json {{"a":-}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 5
"{"a":- <--Error-- }"}}

test json-1.15 {Parse JSON - nested object} {
    set doc [dom parse -json {["a",["aa","bb"],"b"]}]
    set result [$doc asXML -indent none]
    $doc delete
    set result
} "a<arraycontainer>aabb</arraycontainer>b"

set notJsons {
    {{null}}
    {{1.23}}
    {{"string"}}
    {{"e":}}
}
test json-1.16 {Invalid input} {nonetest} {
    set result ""
    set ind 0
    foreach notJson $notJsons {
        if {![catch {dom parse -json $notJson docNode} errMsg]} {
            lappend result $errMsg
        }
    }
    set result
} ""

test json-1.17 {Literal binary 0 (NUL, '\0') is not allowed in input} {nonetest} {
    catch {dom parse -json "\"a\u0000\""}
} 1

test json-1.18 {Escaped binary 0 (NUL, '\0') is OK} {
    dom parse -json "\"a\\u0000\"" doc
    set result [$doc asJSON]
    $doc delete
    set result
} "\"a\\u0000\""

test json-1.19 {Invalid input - incomplete \u escape} {nonetest} {
    set result 1
    foreach jsonstr {
        "ab\u00"
        "ab\ua"
        "ab\u12"
        "ab\u123"
        "ab\u123g"

test json-3.4.1 {unescaping} {
    set doc [dom parse -jsonroot json -json {["\\a","\u0071"]}]
    set result [$doc asXML -indent none]
    $doc delete
    set result
} {<json>\aq</json>}

test json-3.5 {unescaping} {nonetest} {
    set result [catch {dom parse -json {{"this":"a\lb"}}} errMsg]
    list $result $errMsg
} {1 {error "JSON syntax error" at position 11
"{"this":"a\l <--Error-- b"}"}}

test json-3.6 {unescaping} {
    set doc [dom parse -json {{"this":"a\nbc"}}]

			4,
			"abc"
		]
	},
	"b": "bvalue"
}}

if {[info commands _dom] eq ""} {

test json-7.1 {jsonType} {
    set doc [dom parse {<j>foo</j>}]
    set root [$doc documentElement]
    set result [list]
    lappend result [$root asJSON]
    lappend result [$root jsonType]
    $root jsonType ARRAY

        nodeCmds::true
        nodeCmds::false
    }
    set result [$doc asJSON]
    $doc delete
    set result
} {[null,true,false]}
}

test json-9.1 {cloneNode -deep} {
    dom parse -json {[["a",1,"b",{"foo":"bar","baz":"boo"},null],"",null]} doc
    dom createDocument some other
    $other documentElement root
    $root appendChild [[$doc firstChild] cloneNode -deep]
    set result [[$root firstChild] asJSON]

    } {
        set doc [dom parse -json $json]
        lappend result [$doc asTypedList]
        $doc delete
    }
    set result
} {{STRING {string foo}} NULL TRUE FALSE {NUMBER -1.23}}

if {[info commands _dom] eq ""} {

test json-12.1 {createFromTypedList} {
    set doc [dom createFromTypedList {OBJECT {Titel {STRING Wirtschaftsinformatik} Keywords {ARRAY {{STRING Introduction} {STRING Basics}}} Year {NUMBER 2022}}}]
    set result [$doc asJSON]
    $doc delete
    set result
} {{"Titel":"Wirtschaftsinformatik","Keywords":["Introduction","Basics"],"Year":2022}}

        } else {
            lappend result 1
        }
        $doc delete
    }
    set result
} {1 1 1 1 1}

test json-12.5 {createFromTypedList} {
    set result ""
    foreach wrong {
        NUL
        ""
        {one two}
        {STRING two three}
    } {
        catch {dom createFromTypedList $wrong} errMsg
        lappend result $errMsg
    }
    set result
} {{Invalid typed list format: Unkown symbol "NUL".} {Invalid typed list format: Empty list.} {Invalid typed list format: Unkown symbol "one".} {Invalid typed list format: Too much list elements.}}

test json-12.6 {createFromTypedList} {
    catch {dom createFromTypedList {OBJECT {one {STRING two} two {}}}} errMsg
    set errMsg
} {Invalid typed list format: object property "two": Empty list.}

test json-12.7 {createFromTypedList} {
    catch {dom createFromTypedList {OBJECT {one {STRING two} two {ARRAY {{NUMBER 1} {NULL foo}}}}}} errMsg
    set errMsg
} {Invalid typed list format: object property "two": array element 2: No value expected for NULL.}

}

if {[info commands _dom] eq ""} {
    rename dom _dom
    proc dom {args} {
        if {[lindex $args 0] != "parse" || [lsearch -exact $args "-json"] < 0} {
            return [uplevel 1 [linsert $args 0 _dom]]
        }

            }
        }
        if {[catch {
            _dom parse -json $data doc
        } errMsg]} {
            # Some tests check if invalid json data is detected. Since
            # we need valid json data for what is tested here that
            # tests should be marked with constraint nonetest. To
            # raise error here does not help much because if the test
            # data is expected to be invalid the command will be
            # [catch]ed. Therefore the puts to catch attention.
            puts  "Unexpeced invalid json data '$data'"
        }
        set njson [$doc asJSON]
        set typedList [$doc asTypedList]