<command><cmd>dom</cmd> <method>createDocumentFromTypedList</method> <m>typedList</m> ?<m>objVar</m>?</command>
          <desc><p>Creates a new DOM document from the argument <m>typedList</m>.
          The <m>objVar</m> argument controls the memory handling as
          explained above.</p>

          <p>The <m>typedList</m> argument must be a Tcl list and must
          follow the format of the output of the document command
          method <m>asTypedList</m>, see there.</p></desc>
        </commanddef>
        
        <commanddef>
          <command><cmd>dom</cmd> <method>createNodeCmd</method>
<m>?-returnNodeCmd?</m> <m>?-tagName name?</m> <m>?-jsonType jsonType?</m> <m>?-namespace URI?</m> <m>(element|comment|text|cdata|pi)Node</m> <m>commandName</m></command>
          <desc>This method creates Tcl commands, which in turn create
          tDOM nodes. Tcl commands created by this command are only

      <commanddef>
        <command><m>@attrName</m></command>
        <desc>Returns the value of the attribute <m>attrName</m>.  Short cut
for <m>getAttribute</m>.</desc>
      </commanddef>

      <commanddef>
        <command><method>jsonType</method> <m>?(OBJECT|ARRAY|NONE)|(STRING|NUMBER|TRUE|FALSE|NULL|NONE)?</m></command>
        <desc>Only element and text nodes may have a JSON type and
        only this types of nodes support the <m>jsonType</m> method;
        the other node types return error if called with this method.
        Returns the jsonType of the node. If the optional argument is
        given, the JSON type of the node is set to the given type and
        returned. Valid type arguments for element nodes are OBJECT,
        ARRAY and NONE. Valid type arguments for text nodes are

    int  nestingDepth;
    int  maxnesting;
    char *arrItemElm;
    char *buf;
    domLength len;
} JSONParse;

#define SetResult(str) Tcl_ResetResult(interp); \
                     Tcl_SetStringObj(Tcl_GetObjResult(interp), (str), -1)

#define errReturn(i,j) {jparse->state = j; return (i);}
    

/* #define DEBUG */
#ifdef DEBUG
# define DBG(x) x
#else
# define DBG(x) 
#endif

        i += clen;
    }
}

/* Parse a single JSON value which begins at json[i]. Return the index
 * of the first character past the end of the value parsed. */

static domLength jsonParseValue (
    domNode   *parent,
    char      *json,
    domLength  i,
    JSONParse *jparse
    )
{
    char c, save;

        return j;
    } else if (c == '\0') {
        return 0;   /* End of input */
    } else {
        errReturn(i,JSON_SYNTAX_ERR);
    }
}

/* Helper function which checks if a given string is a JSON number. */
int
isJSONNumber (
    char *num,
    domLength numlen
    )
{
    domLength i;
    int seenDP, seenE;
    unsigned char c;
    
    if (numlen == 0) return 0;
    seenDP = 0;
    seenE = 0;
    i = 0;
    c = num[0];
    if (!(c == '-' || (c>='0' && c<='9'))) return 0;
    if (c<='0') {
        i = (c == '-' ? i+1 : i);
        if (i+1 < numlen) {
            if (num[i] == '0' && num[i+1] >= '0' && num[i+1] <= '9') {
                return 0;
            }
        }
    }
    i = 1;
    for (; i < numlen; i++) {
        c = num[i];
        if (c >= '0' && c <= '9') continue;
        if (c == '.') {
            if (num[i-1] == '-') return 0;
            if (seenDP) return 0;
            seenDP = 1;
            continue;
        }
        if (c == 'e' || c == 'E') {
            if (num[i-1] < '0') return 0;
            if (seenE) return 0;
            seenDP = seenE = 1;
            c = num[i+1];
            if (c == '+' || c == '-') {
                i++;
                c = num[i+1];
            }
            if (c < '0' || c > '9') return 0;
            continue;
        }
        break;
    }
    /* Catches a plain '-' without following digits */
    if (num[i-1] < '0') return 0;
    /* Catches trailing chars */
    if (i < numlen) return 0;
    return 1;
}

static inline int
getJSONTypeFromList (
    Tcl_Interp *interp,
    Tcl_Obj *list,
    Tcl_Obj **typeValue
    )
{
    Tcl_Obj *symbol;
    char *s;
    domLength slen;
    
    if (Tcl_ListObjIndex (interp, list, 0, &symbol) != TCL_OK) {
        return -1;
    }
    if (!symbol) {
        /* Empty lists are not allowed. */
        SetResult ("Invalid list format: Empty list.");
        return -1;
    }
    Tcl_ListObjIndex (interp, list, 1, typeValue);
    s = Tcl_GetStringFromObj (symbol, &slen);
    if (strcmp (s, "STRING") == 0) {

        if (*typeValue == NULL) {
            SetResult ("Invalid list format: Missing value for STRING.");

            return -1;
        }
        return JSON_STRING;
    } else if (strcmp (s, "OBJECT") == 0) {

        if (*typeValue == NULL) {
            SetResult ("Invalid list format: Missing value for OBJECT.");

            return -1;
        }
        return JSON_OBJECT;
    } else if (strcmp (s, "NUMBER") == 0) {

        if (*typeValue == NULL) {
            SetResult ("Invalid list format: Missing value for NUMBER.");
            return -1;
        }
        s = Tcl_GetStringFromObj (*typeValue, &slen);
        if (!isJSONNumber (s, slen)) {
            /* Invalid JSON nummber 
               TODO: appropriate error msg */
            SetResult ("Invalid list format: Not a valid NUMBER value.");
            return -1;
        }
        return JSON_NUMBER;
    } else if (strcmp (s, "ARRAY") == 0) {

        if (*typeValue == NULL) {
            SetResult ("Invalid list format: Missing value for ARRAY.");

            return -1;
        }
        return JSON_ARRAY;
    } else if (strcmp (s, "TRUE") == 0) {
        if (*typeValue != NULL) {
            SetResult ("Invalid list format: No value expected for NULL.");
        }
        return JSON_TRUE;
    } else if (strcmp (s, "FALSE") == 0) {
        if (*typeValue != NULL) {
            SetResult ("Invalid list format: No value expected for NULL.");
        }
        return JSON_FALSE;
    } else if (strcmp (s, "NULL") == 0) {
        if (*typeValue != NULL) {
            SetResult ("Invalid list format: No value expected for NULL.");
        }
        return JSON_NULL;
    } else {
        if (*typeValue != NULL) {
            SetResult ("Invalid list format.");
        }
        return -1;
    }            
}

static int
TypedList2DOMWorker (
    Tcl_Interp *interp,

                if (TypedList2DOMWorker (interp, pnode, pdetail) != TCL_OK) {
                    return TCL_ERROR;
                }
            } else {
                /* The other json types are represented by a text node.*/
                switch (jsonType) {
                case JSON_NUMBER:


                case JSON_STRING:
                    str = Tcl_GetStringFromObj (pdetail, &strl);
                    break;
                default:
                    str = "";
                    strl = 0;
                    break;

                container->info = JSON_ARRAY;                
                TypedList2DOMWorker (interp, container, adetail);
                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);
                    break;
                default:
                    str = "";
                    strl = 0;
                    break;
                }
                textNode = domNewTextNode (parent->ownerDocument,
                                           str, strl, TEXT_NODE);
                textNode->info = jsonType;
                domAppendChild (parent, (domNode *) textNode);
                break;
            }
        }
        break;





    default:
        /* Every "text node" JSON values are either done directly by





         * TypedList2DOM() or inline in the OBJECT and ARRAY cases in




         * this function. */
        /* TODO: appropriate error msg */
        return TCL_ERROR;









    }
    return TCL_OK;
}
    
domDocument *
TypedList2DOM (
    Tcl_Interp *interp,

    jsonType = getJSONTypeFromList (interp, typedList, &value);
    if (jsonType < 0) {
        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) {
            goto error;
        }

    } 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;
error:
    tcldom_deleteDoc (interp, doc);
    return NULL;
}

    );

domDocument *
TypedList2DOM (
    Tcl_Interp *interp,
    Tcl_Obj *typedList
    );

int
isJSONNumber (
    char *num,
    domLength numlen
    );

        writeChars(jstring, channel, "}",1);
        break;
    default:
        break;
    }
}



























































/*----------------------------------------------------------------------------
|   tcldom_treeAsJSON
|
\---------------------------------------------------------------------------*/
static
void tcldom_treeAsJSON (

    Tcl_IncrRefCount (c.array);
    Tcl_IncrRefCount (c.null);
    Tcl_IncrRefCount (c.true);
    Tcl_IncrRefCount (c.false);
    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.true);

    }}
    set doc [dom parse -json $json]
    set result [$doc asTypedList]
    $doc delete
    set result
} {OBJECT {{one two} {STRING abc} one\{two {STRING abc} { one two } {STRING edf}}}

test json-11.4 {asTypedList} {
    set result ""
    foreach json {
        {"string foo"}
        null
        true
        false
        -1.23
    } {
        set doc [dom parse -json $json]
        lappend result [$doc asTypedList]
        $doc delete
    }
    set result
} {{STRING {string foo}} NULL TRUE FALSE {NUMBER -1.23}}

test json-12.1 {createDocumentFromTypedList} {
    set doc [dom createDocumentFromTypedList {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}}

    }
    error "Invalid turnaround."
}
test json-12.3 {createDocumentFromTypedList} {
    createFromTypedList {OBJECT {Titel {STRING Wirtschaftsinformatik} Keywords {ARRAY {{STRING Introduction} {STRING Basics}}} Year {NUMBER 2022}}}
} {}

test json-12.4 {createDocumentFromTypedList} {
    set result ""
    foreach json {
        {STRING foo}
        NULL
        TRUE
        FALSE
        {NUMBER -1.23}
    } {
        set doc [dom createDocumentFromTypedList $json]
        set this [$doc asTypedList]
        if {$json ne $this} {
            lappend result "json $json this $this"
        } else {
            lappend result 1
        }
        $doc delete
    }
    set result
} {1 1 1 1 1}