Max 5 API Reference

jit.xml.c

#include "ext.h"
#include "ext_obex.h"
#include "ext_strings.h"
#include "jit.common.h"
#include "jit.xml.h"
#include "expat.h"
#include "jit.charset.h"

#define XML_MAX_ATOM_COUNT 2048

/*
    a minimal DOM implementation informed by W3 Document Object Model (Core) Level:
    http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core.html

    The DOM presents documents as a hierarchy of Node objects that also implement other, 
    more specialized interfaces. Some types of nodes may have child nodes of various types, 
    and others are  leaf nodes that cannot have anything below them in the document structure. 
    The node types, and which node types they may have as  children, are as follows:


    -   Document:  Element (maximum of  one), ProcessingInstruction, Comment,  DocumentType     
    *   DocumentFragment:  Element,  ProcessingInstruction, Comment,  Text, CDATASection,  EntityReference 
    (*) DocumentType: no children
    *   EntityReference: Element,  ProcessingInstruction, Comment,  Text, CDATASection,  EntityReference 
    -   Element: Element,  Text,  Comment,  ProcessingInstruction, CDATASection,  EntityReference
    -   Attr: Text, EntityReference
    *   ProcessingInstruction: no children
    -   Comment: no children
    -   Text: no children
    -   CDATASection: no children
    *   Entity: Element,  ProcessingInstruction, Comment,  Text, CDATASection,  EntityReference
    *   Notation: no children

    currently no support for items marked with *
    later could move into kernel if desired
    
*/

t_class *_jit_xml_document_class=NULL;
t_class *_jit_xml_element_class=NULL;
t_class *_jit_xml_attribute_class=NULL;
t_class *_jit_xml_text_class=NULL;
t_class *_jit_xml_comment_class=NULL;
t_class *_jit_xml_cdata_class=NULL;


#ifdef __APPLE_CC__
t_symbol *ps_nobox,*ps_atomarray,*ps_nodevalue,*ps_specified;
t_symbol *ps_document,*ps_element,*ps_attribute,*ps_text,*ps_comment,*ps_cdata;
#else
static t_symbol *ps_nobox,*ps_atomarray,*ps_nodevalue,*ps_specified;
static t_symbol *ps_document,*ps_element,*ps_attribute,*ps_text,*ps_comment,*ps_cdata;
#endif

void jit_xml_text_toatoms(char *s, long *ac, t_atom *av);
void jit_xml_appendatom(t_atom *a, char *s);
void jit_xml_atoms_totext(char *s, long ac, t_atom *av);
void jit_xml_node_encode_and_write(t_jit_xml_node *x, t_filehandle fh, long *count, char *data);
long jit_xml_document_decode(t_jit_xml_document *x, const char *data, char **outdata);
void jit_xml_document_xmlparse_xmldecl(t_jit_xml_document *x, const char *version, const char *encoding, int standalone);
void jit_xml_document_createheader(t_jit_xml_document *x, t_symbol *encoding);
char *jit_xml_convert_entities(char *instr, long *len);

t_jit_err jit_xml_init(void)
{
    t_class *c;
    long attrflags=0;
    void *attr;

    ps_nobox            = gensym("nobox");
    ps_atomarray        = gensym("atomarray");
    ps_nodevalue        = gensym("nodevalue");
    ps_specified        = gensym("specified");
    ps_document         = gensym("document");
    ps_element          = gensym("element");
    ps_attribute        = gensym("attribute");
    ps_text             = gensym("text");
    ps_comment          = gensym("comment");
    ps_cdata            = gensym("cdata");
    
    // jit_xml_doccument class ---------------------------------------
    
    c = jit_class_new("jit_xml_document", (method)jit_xml_document_new, (method)jit_xml_document_free, 
        (short)sizeof(t_jit_xml_document), A_GIMME, 0);     

    //  A_CANT for now, (maybe later maked typed wrapper versions for exposing in patcher/javascript)
    jit_class_addmethod(c,(method)jit_xml_document_read,                    "read",                     A_GIMME, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_write,                   "write",                    A_GIMME, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_createelement,           "createelement",            A_CANT, 0); 
//  jit_class_addmethod(c,(method)jit_xml_document_createdocumentfragment,  "createdocumentfragment",   A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_createtextnode,          "createtextnode",           A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_createcomment,           "createcomment",            A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_createcdatasection,      "createcdatasection",       A_CANT, 0); 
//  jit_class_addmethod(c,(method)jit_xml_document_createprocessinginstruction, "createprocessinginstruction",  A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_createattribute,         "createattribute",          A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_getelementsbytagname,    "getelementsbytagname",     A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_document_print,                   "print",                    0); 

    jit_xml_node_addinterface(c);

    //attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW ;    
    attr = jit_object_new(_jit_sym_jit_attr_offset,"filename",_jit_sym_symbol,attrflags,
        (method)0L,(method)jit_xml_document_filename,calcoffset(t_jit_xml_document,filename));
    jit_class_addattr(c,attr);
    
    jit_class_register(c);  
    _jit_xml_document_class = c;        


    // jit_xml_element class ---------------------------------------
    
    c = jit_class_new("jit_xml_element", (method)jit_xml_element_new, (method)jit_xml_element_free, 
        (short)sizeof(t_jit_xml_element), A_GIMME, 0);      

    //  A_CANT for now, (maybe later maked typed wrapper versions for exposing in patcher/javascript)
    jit_class_addmethod(c,(method)jit_xml_element_getattribute,             "getattribute",             A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_element_setattribute,             "setattribute",             A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_element_removeattribute,          "removeattribute",          A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_element_getattributenode,         "getattributenode",         A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_element_setattributenode,         "setattributenode",         A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_element_removeattributenode,      "removeattributenode",      A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_element_getelementsbytagname,     "getelementsbytagname",     A_CANT, 0); 
//  jit_class_addmethod(c,(method)jit_xml_element_normalize,                "normalize",                A_CANT, 0); 

    jit_xml_node_addinterface(c);

    attrflags = JIT_ATTR_SET_OPAQUE_USER;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"tagname",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,nodename)); //mapping redundantly to nodename
    jit_class_addattr(c,attr);
    
    jit_class_register(c);  
    _jit_xml_element_class = c;     


    // jit_xml_attribute class ---------------------------------------
    
    c = jit_class_new("jit_xml_attribute", (method)jit_xml_attribute_new, (method)jit_xml_attribute_free, 
        (short)sizeof(t_jit_xml_attribute), A_GIMME, 0);        

    jit_xml_node_addinterface(c);

    attrflags = JIT_ATTR_SET_OPAQUE_USER;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"name",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,nodename)); //mapping redundantly to nodename
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"specified",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_attribute,specified));
    jit_class_addattr(c,attr);
    
    jit_class_register(c);  
    _jit_xml_attribute_class = c;       


    // jit_xml_text class ---------------------------------------
    
    c = jit_class_new("jit_xml_text", (method)jit_xml_text_new, (method)jit_xml_text_free, 
        (short)sizeof(t_jit_xml_text), A_GIMME, 0);     

    jit_class_addmethod(c,(method)jit_xml_text_splittext,               "splittext",                A_CANT, 0); 
    jit_xml_charnode_addinterface(c);
    
    jit_class_register(c);  
    _jit_xml_text_class = c;        


    // jit_xml_comment class ---------------------------------------
    
    c = jit_class_new("jit_xml_comment", (method)jit_xml_comment_new, (method)jit_xml_comment_free, 
        (short)sizeof(t_jit_xml_comment), A_GIMME, 0);      

    jit_xml_charnode_addinterface(c);

    jit_class_register(c);  
    _jit_xml_comment_class = c;     


    // jit_xml_cdata class ---------------------------------------
    
    c = jit_class_new("jit_xml_cdata", (method)jit_xml_cdata_new, (method)jit_xml_cdata_free, 
        (short)sizeof(t_jit_xml_cdata), A_GIMME, 0);        

    jit_class_addmethod(c,(method)jit_xml_cdata_splittext,              "splittext",                A_CANT, 0); 
    jit_xml_charnode_addinterface(c);
    
    jit_class_register(c);  
    _jit_xml_cdata_class = c;       

    return JIT_ERR_NONE;
}

/*------------------------------------------------------------------------------
    jit_xml_node
-------------------------------------------------------------------------------*/


t_jit_err jit_xml_node_addinterface(t_class *c)
{
    long attrflags = 0;
    t_jit_object *attr;

    // node interface attributes. all except nodevalue are supposedly readonly
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"nodevalue",_jit_sym_atom,0/*no max*/,attrflags,
        (method)jit_xml_node_getnodevalue,(method)jit_xml_node_nodevalue,
        calcoffset(t_jit_xml_node,nodevaluecount),calcoffset(t_jit_xml_node,nodevalue));
    jit_class_addattr(c,attr);

    attrflags = JIT_ATTR_SET_OPAQUE_USER;    
    attr = jit_object_new(_jit_sym_jit_attr_offset,"nodename",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,nodename));
    jit_class_addattr(c,attr);

    // in DOM spec nodetype is an integer, but we will be using symbols: element, attribute, text, comment, document, etc. 
    attr = jit_object_new(_jit_sym_jit_attr_offset,"nodetype",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,nodetype));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"parentnode",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,parentnode));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"childnodes",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,childnodes));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"firstchild",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,firstchild));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"lastchild",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,lastchild));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"previoussibling",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,previoussibling));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"nextsibling",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,previoussibling));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"attributes",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,attributes));
    jit_class_addattr(c,attr);

    attr = jit_object_new(_jit_sym_jit_attr_offset,"ownerdocument",_jit_sym_object,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_node,ownerdocument));
    jit_class_addattr(c,attr);

    // node interface methods (maybe later maked typed wrapper versions for exposing in patcher/javascript)
    jit_class_addmethod(c,(method)jit_xml_node_insertbefore,        "insertbefore",         A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_replacechild,        "replacechild",         A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_removechild,         "removechild",          A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_appendchild,         "appendchild",          A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_haschildnodes,       "haschildnodes",        A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_clonenode,           "clonenode",            A_CANT, 0); // need to implement
    // utilities
    jit_class_addmethod(c,(method)jit_xml_node_removeallchildren,   "removeallchildren",    A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_setnodevalasstring,  "setnodevalueasstring", A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_node_getnodevalasstring,  "getnodevalueasstring", A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_nodevalue,           "setnodevalueasatoms",  A_CANT, 0);
    jit_class_addmethod(c,(method)jit_xml_node_getnodevalue,        "getnodevalueasatoms",  A_CANT, 0); // need to implement

    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_insertbefore(t_jit_xml_node *x, t_jit_xml_node *newchild, t_jit_xml_node *refchild)
{
    long i;
    
    if (newchild&&!x->childnodes) {
        x->childnodes = jit_linklist_new();
    }
    if (x->childnodes) {
        jit_global_critical_enter();
        if (refchild)
            i = jit_linklist_objptr2index(x->childnodes,refchild);
        else 
            i = 0;
            
        if (i<0) i=0; //always insert even if refchild not in nodelist
        
        jit_linklist_insertindex(x->childnodes,newchild,i);
        // update sibling attributes
        newchild->previoussibling = jit_linklist_getindex(x->childnodes,i-1);
        newchild->nextsibling = jit_linklist_getindex(x->childnodes,i+1);
        if (newchild->previoussibling)
            newchild->previoussibling->nextsibling = newchild;
        if (newchild->nextsibling)
            newchild->nextsibling->previoussibling = newchild;
        // update parent/document attributes
        newchild->parentnode = x;
        newchild->ownerdocument = x->ownerdocument;
        // update children attributes
        x->firstchild = jit_linklist_getindex(x->childnodes,0);
        x->lastchild = jit_linklist_getindex(x->childnodes,jit_linklist_getsize(x->childnodes-1));
        jit_global_critical_exit();
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_xml_node_replacechild(t_jit_xml_node *x, t_jit_xml_node *newchild, t_jit_xml_node *refchild)
{
    long i;
    
    if (x->childnodes&&refchild) {
        jit_global_critical_enter();
        if ((i=jit_linklist_objptr2index(x->childnodes,refchild))>=0) { 
            jit_linklist_insertindex(x->childnodes,newchild,i);
            jit_linklist_deleteindex(x->childnodes,i+1);
            // update sibling attributes
            newchild->previoussibling = jit_linklist_getindex(x->childnodes,i-1);
            newchild->nextsibling = jit_linklist_getindex(x->childnodes,i+1);
            if (newchild->previoussibling)
                newchild->previoussibling->nextsibling = newchild;
            if (newchild->nextsibling)
                newchild->nextsibling->previoussibling = newchild;
            // update parent/document attributes
            newchild->parentnode = x;
            newchild->ownerdocument = x->ownerdocument;
            // update children attributes
            x->firstchild = jit_linklist_getindex(x->childnodes,0);
            x->lastchild = jit_linklist_getindex(x->childnodes,jit_linklist_getsize(x->childnodes-1));
        }
        jit_global_critical_exit();
//      jit_object_free(refchild); //there might be some chance we don't want to free?
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_xml_node_removechild(t_jit_xml_node *x, t_jit_xml_node *refchild)
{
    long i;
    
    if (x->childnodes&&refchild) {
        jit_global_critical_enter();
        if ((i=jit_linklist_objptr2index(x->childnodes,refchild))>=0) { 
            jit_linklist_deleteindex(x->childnodes,i);
            
            // update children attributes
            x->firstchild = jit_linklist_getindex(x->childnodes,0);
            x->lastchild = jit_linklist_getindex(x->childnodes,jit_linklist_getsize(x->childnodes)-1);
        }
        jit_global_critical_exit();
//      jit_object_free(refchild); //there might be some chance we don't want to free?
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

t_jit_err jit_xml_node_appendchild(t_jit_xml_node *x, t_jit_xml_node *newchild)
{
    if (newchild&&!x->childnodes) {
        x->childnodes = jit_linklist_new();
    }
    if (x->childnodes) {
        jit_global_critical_enter();
        jit_linklist_append(x->childnodes,newchild);
        // update sibling attributes
        newchild->previoussibling = jit_linklist_getindex(x->childnodes,jit_linklist_getsize(x->childnodes)-2);
        newchild->nextsibling = NULL;
        if (newchild->previoussibling)
            newchild->previoussibling->nextsibling = newchild;
        // update parent/document attributes
        newchild->parentnode = x;
        newchild->ownerdocument = (x->ownerdocument) ? x->ownerdocument : (t_jit_xml_document *)x;
        // update children attributes
        x->firstchild = jit_linklist_getindex(x->childnodes,0);
        x->lastchild = newchild;
        jit_global_critical_exit();
        return JIT_ERR_NONE;
    }
    return JIT_ERR_GENERIC;
}

long jit_xml_node_haschildnodes(t_jit_xml_node *x)
{
    return (long)((x->childnodes!=NULL)&&(jit_linklist_getsize(x->childnodes)>0));
}

t_jit_xml_node *jit_xml_node_clonenode(t_jit_xml_node *x, long deep)
{
    // TODO: based on element type duplicate the entire structure
    return NULL;
}

t_jit_err jit_xml_node_removeallchildren(t_jit_xml_node *x)
{
    if (x->childnodes) {
        jit_object_free(x->childnodes); // might want to chuck rather than free?
        x->childnodes = NULL;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_nodevalue_clear(t_jit_xml_node *x);
t_jit_err jit_xml_node_nodevalue_clear(t_jit_xml_node *x)
{
    long i;
    
    for (i=0;i<x->nodevaluecount;i++) {
        if ((x->nodevalue[i].a_type==A_OBJ)&&(x->nodevalue[i].a_w.w_obj!=NULL))
            jit_object_free(x->nodevalue[i].a_w.w_obj);
    }
//  if (ac!=x->nodevaluecount) { // this was a bug
        if (x->nodevalue)
            jit_freebytes(x->nodevalue,x->nodevaluecount*sizeof(t_atom));       
        x->nodevalue = NULL;
        x->nodevaluecount = 0;
//  }
    if (x->nodeflags == NODE_VALUE_SET_AS_STRING && x->nodestring) {
        jit_freebytes(x->nodestring, strlen(x->nodestring) + 1);
        x->nodestring = NULL;
    }
    x->nodeflags = NODE_VALUE_NOT_SET;

    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_nodevalue(t_jit_xml_node *x, void *attr, long ac, t_atom *av)
{
    long i;
        
    jit_xml_node_nodevalue_clear(x);

    if (ac&&av) {
        x->nodevaluecount = ac;
        x->nodevalue = (t_atom *)jit_getbytes(x->nodevaluecount*sizeof(t_atom));        
        for (i=0;i<ac;i++)
            x->nodevalue[i] = av[i];
            
        x->nodeflags = NODE_VALUE_SET_AS_ATOMS;
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_getnodevalue(t_jit_xml_node *x, void *attr, long *ac, t_atom **av)
{
    long i;
    
    // ignore attr pointer, also using as method "getnodevalueasatoms"  
    // later could handle object cases and parse into atoms or something? 
    // maybe then would separate this fun and getnodevalues as atoms?
    
    if (x->nodeflags == NODE_VALUE_SET_AS_ATOMS) {
        if (*ac&&*av) {
            //memory passed in, use it
            if ((*ac)>x->nodevaluecount)
                *ac = x->nodevaluecount;
        } else {
            *ac = x->nodevaluecount;
            if (x->nodevaluecount)
                *av = jit_getbytes(x->nodevaluecount*sizeof(t_atom));
            else 
                *av = NULL; 
        }
        
        for (i=0;i<(*ac);i++)
            (*av)[i] = x->nodevalue[i]; 
    } else if (x->nodeflags == NODE_VALUE_SET_AS_STRING && x->nodestring) {
        t_atom argv[XML_MAX_ATOM_COUNT];
        long argc = 0;

        jit_xml_text_toatoms(x->nodestring, &argc, argv);

        if (*ac&&*av) {
            //memory passed in, use it
            if ((*ac)>argc)
                *ac = argc;
        } else {
            *ac = argc;
            if (argc)
                *av = jit_getbytes(argc*sizeof(t_atom));
            else 
                *av = NULL; 
        }

        for (i = 0; i < (*ac); i++) {
            (*av)[i] = argv[i];
        }
    }

    return JIT_ERR_NONE;
}

// need to implement getnodevalueasatoms which will serialize objects into atom vals?


void jit_xml_text_toatoms(char *s, long *ac, t_atom *av)
{
    long n,eaten;
    char *p;
    
    *ac = 0;
    eaten = 0;
    n = strlen(s);
    p=(char *)jit_getbytes(n+1);
    //jit_object_post((t_object *)x,"text to atoms: %s",s);
    while (readatom(p, &s, &eaten, n, av)) {
        /*
        switch (av->a_type) {
        case A_SYM:
            jit_object_post((t_object *)x,"symbol: %s",av->a_w.w_sym->s_name);
            break;
        case A_LONG:
            jit_object_post((t_object *)x,"long: %d",av->a_w.w_long);
            break;
        case A_FLOAT:
            jit_object_post((t_object *)x,"float: %f",av->a_w.w_float);
            break;
        }
        */
        (*ac)++;
        av++;
    }
    jit_freebytes(p,n+1);
}


void jit_xml_appendatom(t_atom *a, char *s) 
{
    char buf[512];
    char fbuf[128];
    char c,*p;
    
    c = a->a_type;
    buf[0] = 0;
    if (c == A_SYM)
        sprintf(buf, "%s ", (a->a_w.w_sym) ? a->a_w.w_sym->s_name : "");
    else if (c == A_OBJ)
        sprintf(buf, "%s ", object_classname(a->a_w.w_obj)->s_name);
    else if (c == A_LONG)
        sprintf(buf, "%ld ", a->a_w.w_long);
    else if (c == A_DOLLAR)
        sprintf(buf, "$%ld ", a->a_w.w_long);
    else if (c == A_FLOAT) {
        // chomp trailing zeros
        sprintf(fbuf,"%f",a->a_w.w_float);
        p = fbuf+strlen(fbuf)-1;
        while ((p>fbuf)&&(*p=='0')) {
            *p = 0;
            p--;
        }
        sprintf(buf,"%s ",fbuf);
    }
    else if (c == A_DOLLSYM)
        sprintf(buf,"$%s",a->a_w.w_sym->s_name);
    else
        return;
    //jit_object_post((t_object *)x,"appendatom %s",buf);
    strcat(s,buf);
}

void jit_xml_atoms_totext(char *s, long ac, t_atom *av)
{
    long i;
    long sl;
    
    s[0] = 0;
    for (i=0; i < ac; i++,av++)
        jit_xml_appendatom(av,s);
    sl = strlen(s);
    if (s[sl-1] == ' ')
        s[sl-1] = 0;
}

t_jit_err jit_xml_node_setnodevalasstring(t_jit_xml_node *x, char *s)
{   
//  t_atom av[1024];
//  long ac=1024;
//  char tmp[1024];
    
    jit_xml_node_nodevalue_clear(x);

    x->nodestring = (char *)jit_getbytes(strlen(s) + 1);
    strcpy(x->nodestring, s);

    x->nodeflags = NODE_VALUE_SET_AS_STRING;

//  jit_xml_text_toatoms(s,&ac,av); 
//  object_attr_setvalueof(x,ps_nodevalue,ac,av);
    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_getnodevalasstring(t_jit_xml_node *x, long *len, char **s)
{
    char temp[8192];
    char *tmp;
    t_atom *av=NULL;
    long i,ac=0;
    
    if (x->nodeflags == NODE_VALUE_SET_AS_ATOMS) {
        temp[0]=0;
        
        object_attr_getvalueof(x,ps_nodevalue,&ac,&av);
        jit_xml_atoms_totext(temp,ac,av);
        jit_freebytes((char *)av,sizeof(t_atom)*ac);
        tmp = &temp[0];
    } else if (x->nodeflags == NODE_VALUE_SET_AS_STRING && x->nodestring) {
        tmp = x->nodestring;
    }
    if (*s&&*len) {
        //memory passed in, use it
        *len = MIN((long)strlen(tmp)+1,*len);
    } else {
        *len = strlen(tmp)+1;
        *s = jit_getbytes(*len);
    }
    for (i=0;i<((*len)-1);i++) {
        (*s)[i] = tmp[i];
    }
    (*s)[i] = 0;

    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_new(t_jit_xml_node *x, t_symbol *nodetype)
{
    x->nodename         = _jit_sym_nothing;
    x->nodevalue        = NULL;
    x->nodevaluecount   = 0;
    x->nodetype         = nodetype ? nodetype : _jit_sym_nothing;
    x->parentnode       = NULL;
    x->childnodes       = NULL;
    x->firstchild       = NULL;
    x->lastchild        = NULL;
    x->previoussibling  = NULL;
    x->nextsibling      = NULL;
    x->attributes       = NULL;
    x->ownerdocument    = NULL;
    x->nodestring       = NULL;
    x->nodeflags        = NODE_VALUE_NOT_SET;

    return JIT_ERR_NONE;
}

t_jit_err jit_xml_node_free(t_jit_xml_node *x)
{
    if (x->childnodes) {
        jit_object_free(x->childnodes);
        x->childnodes = NULL;
    }
    if (x->attributes) {
        jit_object_free(x->attributes);
        x->attributes = NULL;
    }

    jit_xml_node_nodevalue_clear(x);

    x->nodename         = _jit_sym_nothing;
    x->nodevalue        = NULL;
    x->nodevaluecount   = 0;
    x->nodetype         = _jit_sym_nothing;
    x->parentnode       = NULL;
    x->childnodes       = NULL;
    x->firstchild       = NULL;
    x->lastchild        = NULL;
    x->previoussibling  = NULL;
    x->nextsibling      = NULL;
    x->ownerdocument    = NULL;
    x->nodestring       = NULL;
    x->nodeflags        = NODE_VALUE_NOT_SET;
        
    return JIT_ERR_NONE;
}


t_symbol *jit_xml_node_getnodevalue_sym(t_jit_xml_node *x)
{
    long        ac=0;
    t_atom      *av=NULL;
    t_symbol    *rv=_jit_sym_nothing;
    
    if (x) {
        if (((jit_xml_node_getnodevalue(x,NULL,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getsym(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_xml_node_nodevalue_sym(t_jit_xml_node *x, t_symbol *s)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x) {        
        jit_atom_setsym(av,s);
        rv = jit_xml_node_nodevalue(x,NULL,ac,av);
    }
    return rv;
}

long jit_xml_node_getnodevalue_long(t_jit_xml_node *x)
{
    long        ac=0;
    t_atom      *av=NULL;
    long        rv=0;
    
    if (x) {
        if (((jit_xml_node_getnodevalue(x,NULL,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getlong(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_xml_node_nodevalue_long(t_jit_xml_node *x, long c)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x) {        
        jit_atom_setlong(av,c);
        rv = jit_xml_node_nodevalue(x,NULL,ac,av);
    }
    return rv;
}


float jit_xml_node_getnodevalue_float(t_jit_xml_node *x)
{
    long        ac=0;
    t_atom      *av=NULL;
    float       rv=0;
    
    if (x) {
        if (((jit_xml_node_getnodevalue(x,NULL,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getfloat(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_xml_node_nodevalue_float(t_jit_xml_node *x, float f)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x) {        
        jit_atom_setfloat(av,f);
        rv = jit_xml_node_nodevalue(x,NULL,ac,av);
    }
    return rv;
}

long jit_xml_node_getnodevalue_sym_array(t_jit_xml_node *x, long max, t_symbol **vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    
    if (x&&vals) {
        if (((jit_xml_node_getnodevalue(x,NULL,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getsym(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_xml_node_nodevalue_sym_array(void *x, long count, t_symbol **vals)
{
    t_atom      av[XML_MAX_ATOM_COUNT];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setsym(av+i,vals[i]);
        rv = jit_xml_node_nodevalue(x,NULL,count,av);
    }
    return rv;
}

long jit_xml_node_getnodevalue_long_array(t_jit_xml_node *x, long max, long *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    
    if (x&&vals) {
        if (((jit_xml_node_getnodevalue(x,NULL,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getlong(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_xml_node_nodevalue_long_array(void *x, long count, long *vals)
{
    t_atom      av[XML_MAX_ATOM_COUNT];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setlong(av+i,vals[i]);
        rv = jit_xml_node_nodevalue(x,NULL,count,av);
    }
    return rv;
}

long jit_xml_node_getnodevalue_float_array(t_jit_xml_node *x, long max, float *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    
    if (x&&vals) {
        if (((jit_xml_node_getnodevalue(x,NULL,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getfloat(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_xml_node_nodevalue_float_array(void *x, long count, float *vals)
{
    t_atom      av[XML_MAX_ATOM_COUNT];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setfloat(av+i,vals[i]);
        rv = jit_xml_node_nodevalue(x,NULL,count,av);
    }
    return rv;
}

void jit_xml_node_getelementsbytagname_helper(t_jit_xml_node *x, t_symbol *tagname, t_jit_linklist **list);
void jit_xml_node_getelementsbytagname_helper(t_jit_xml_node *x, t_symbol *tagname, t_jit_linklist **list)
{
    long i,count;
    t_jit_xml_node *node;
    
    // depthfirst (preorder) traversal  
    if (/*(x->nodetype==ps_element)&&*/(x->nodename==tagname)) {
        if (!(*list))
            (*list) = jit_linklist_new();
        jit_linklist_append(*list,x);
    }               
    if (x->childnodes) {
        count = jit_linklist_getsize(x->childnodes);
        for (i=0;i<count;i++) {
            node = jit_linklist_getindex(x->childnodes,i);
            jit_xml_node_getelementsbytagname_helper(node,tagname,list);
        }
    }
}




/*------------------------------------------------------------------------------
    jit_xml_charnode
-------------------------------------------------------------------------------*/

t_jit_err jit_xml_charnode_addinterface(t_class *c)
{
    long attrflags = 0;
    t_jit_object *attr;

    jit_xml_node_addinterface(c);

    attrflags = JIT_ATTR_SET_OPAQUE_USER;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"length",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_xml_charnode,length));
    jit_class_addattr(c,attr);

    // chardata interface methods (maybe later maked typed wrapper versions for exposing in patcher/javascript)
    jit_class_addmethod(c,(method)jit_xml_charnode_substringdata,           "substringdata",            A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_charnode_appenddata,              "appenddata",               A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_charnode_insertdata,              "insertdata",               A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_charnode_deletedata,              "deletedata",               A_CANT, 0); 
    jit_class_addmethod(c,(method)jit_xml_charnode_replacedata,             "replacedata",              A_CANT, 0); 

    return JIT_ERR_NONE;
}

char *jit_xml_charnode_substringdata(t_jit_xml_charnode *x, long offset, long count)
{
    char *substr;
    long i;
    
    if (x->data&&(x->length>0)) {
        offset = CLAMP(offset,0,x->length-1);   
        count = CLAMP(count,0,x->length-1-offset);  
        substr = jit_getbytes(count+1);
        for (i=0;i<count;i++)
            substr[i] = x->data[i];
        substr[i] = 0;
        return substr;
    } else {
        return NULL;
    }
} 

t_jit_err jit_xml_charnode_appenddata(t_jit_xml_charnode *x, char *data)
{
    char *newdata;
    char *olddata = x->data;
    long oldlen = x->length;
    long appendlen = strlen(data);
    long newlen = oldlen + appendlen;
    long i,j;

    newdata = jit_getbytes(newlen+1);
    for (i=0;i<oldlen;i++) {
        newdata[i] = olddata[i];
    }
    for (i=oldlen,j=0;i<newlen;i++,j++) {
        newdata[i] = data[j];
    }
    newdata[newlen] = 0;
    x->data = newdata;
    x->length = newlen;
    if (olddata)
        jit_freebytes(olddata,oldlen+1);    
    return JIT_ERR_NONE;
} 

t_jit_err jit_xml_charnode_insertdata(t_jit_xml_charnode *x, long offset, char *data)
{
    char *newdata;
    char *olddata = x->data;
    long oldlen = x->length;
    long insertlen = strlen(data);
    long newlen = oldlen + insertlen;
    long i,j;

    newdata = jit_getbytes(newlen+1);
    for (i=0;i<offset;i++) {
        newdata[i] = olddata[i];
    }
    for (i=offset,j=0;j<insertlen;i++,j++) {
        newdata[i] = data[j];
    }
    for (i=offset+insertlen,j=offset;i<newlen;i++,j++) {
        newdata[i] = olddata[j];
    }
    newdata[newlen] = 0;
    x->data = newdata;
    x->length = newlen;
    if (olddata)
        jit_freebytes(olddata,oldlen+1);    
    return JIT_ERR_NONE;
} 

t_jit_err jit_xml_charnode_deletedata(t_jit_xml_charnode *x, long offset, long count)
{
    char *newdata;
    char *olddata = x->data;
    long oldlen = x->length;
    long newlen = CLAMP(oldlen-count,offset,oldlen);
    long i,j;

    newdata = jit_getbytes(newlen+1);
    for (i=0;i<offset;i++) {
        newdata[i] = olddata[i];
    }
    for (i=offset,j=offset+(oldlen-newlen);j<newlen;i++,j++) {
        newdata[i] = olddata[j];
    }
    newdata[newlen] = 0;
    x->data = newdata;
    x->length = newlen;
    if (olddata)
        jit_freebytes(olddata,oldlen+1);    
    return JIT_ERR_NONE;
} 

t_jit_err jit_xml_charnode_replacedata(t_jit_xml_charnode *x, long offset, long count, char *data)
{
    // could be more efficient, but hey...
    jit_xml_charnode_deletedata(x,offset,count);
    jit_xml_charnode_insertdata(x,offset,data);
    return JIT_ERR_NONE;
} 

t_jit_err jit_xml_charnode_new(t_jit_xml_charnode *x, t_symbol *nodetype)
{
    x->data = NULL;
    x->length = 0;
    jit_xml_node_new((t_jit_xml_node *)x,nodetype);
    x->node.nodename = nodetype;
    return JIT_ERR_NONE;
} 

t_jit_err jit_xml_charnode_free(t_jit_xml_charnode *x)
{
    if (x->data)
        jit_freebytes(x->data,x->length+1);
    x->data = NULL;
    x->length = 0;
    jit_xml_node_free((t_jit_xml_node *)x);
    return JIT_ERR_NONE;
} 


/*------------------------------------------------------------------------------
    jit_xml_document
-------------------------------------------------------------------------------*/


// probably only accessed as a gettable attribute, but leaving this here as placeholder
void jit_xml_document_filename(t_jit_xml_document *x, t_object *attr, long argc, t_atom *argv)
{
    t_symbol *filename=_jit_sym_nothing;
    
    if (argc&&argv) {
        filename = jit_atom_getsym(argv);
    }
    x->filename = filename;
}

t_jit_err jit_xml_document_read(t_jit_xml_document *x, t_symbol *s, long ac, t_atom *av) //later make gimmeback?
{
    char cname[512];
    char tmp[MAX_PATH_CHARS];
    short path;
    long type;
    long typelist = 'TEXT';
    t_filehandle fh;
    t_handle texthandle;
    long err,rv = 0;
    long size;
    char *txt;
    XML_Parser parser;
    t_atom a[2];
    t_jit_err jerr=JIT_ERR_GENERIC;
    
    strcpy(cname, "<none>");        
    if (ac && av && av->a_type == A_SYM) {
        strcpy(cname, av->a_w.w_sym->s_name);
        if (locatefile_extended(cname, &path, &type, NULL, 0 /*&typelist, 1*/)) {
            //jit_object_error((t_object *)x,"jit_xml_document_read: could not find file %s",cname);
            goto out;
        }
    }
    else {
        if (open_dialog(cname, &path, &type,  NULL, 0 /*&typelist, 1*/))
            goto out;
    }
        
    if (err = path_opensysfile(cname, path, &fh, READ_PERM)) {
        //jit_object_error((t_object *)x,"jit_xml_document_read: could not open file %s",cname);
        goto out;
    }
    x->filename = gensym(cname);
    x->path = path;
    
    // should delete any existing childnodes (and attributes, etc?)
    jit_object_free(x->node.childnodes);
    x->node.childnodes = NULL;

    texthandle = sysmem_newhandle(1);
    if (!texthandle) {
        jit_object_error((t_object *)x,"jit_xml_document: could not allocate buffer for reading file");
        sysmem_freehandle(texthandle);
        sysfile_close(fh);
        goto out;
    }
    
    x->parsernode = (t_jit_xml_node *)x;
    x->parserdepth = 0;
    
    sysfile_readtextfile(fh,texthandle,0,TEXT_LB_UNIX); 
    size = sysmem_handlesize(texthandle);
    sysmem_resizehandle(texthandle,size+1L);        
    txt = *texthandle;
    txt[size] = 0;
    
    //jit_object_post((t_object *)x,"jit_xml_document: read file okay");
    if (parser = XML_ParserCreate(NULL)) {
        XML_SetUserData(parser, x);
        XML_SetXmlDeclHandler(parser, (XML_XmlDeclHandler)jit_xml_document_xmlparse_xmldecl);
        XML_SetElementHandler(parser, 
            (XML_StartElementHandler) jit_xml_document_xmlparse_element_start, 
            (XML_EndElementHandler)jit_xml_document_xmlparse_element_end);
        XML_SetDefaultHandler(parser, (XML_CharacterDataHandler) jit_xml_document_xmlparse_default);
        XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler) jit_xml_document_xmlparse_characterdata);
        XML_SetCommentHandler(parser, (XML_CommentHandler) jit_xml_document_xmlparse_comment);
        XML_SetDoctypeDeclHandler(parser,
              (XML_StartDoctypeDeclHandler) jit_xml_document_xmlparse_doctype_start,
              (XML_EndDoctypeDeclHandler) jit_xml_document_xmlparse_doctype_end);
        XML_SetCdataSectionHandler(parser,
               (XML_StartCdataSectionHandler) jit_xml_document_xmlparse_cdata_start,
               (XML_EndCdataSectionHandler) jit_xml_document_xmlparse_cdata_end);
        // TODO: entity handlers?
        if (!XML_Parse(parser, txt, size, true)) {
            long i,byteoffset,linenumber=1;
            char *sp;

            byteoffset = XML_GetCurrentByteIndex(parser);
            jit_object_error((t_object *)x,"jit_xml_document: error reading file at byte offset %d / %s", 
                byteoffset, XML_ErrorString(XML_GetErrorCode(parser)));
            sp = txt;
            while (sp && sp<(txt+byteoffset)) {
                if (*sp++=='\n') 
                    linenumber++;
            }
            sp = txt+byteoffset;
            for (i=0;(i<255)&&(*sp)&&(sp<(txt+size))&&(*sp!='\n')&&(*sp!='\r');i++,sp++) 
                tmp[i] = *sp;
            tmp[i] = 0;
            jit_object_error((t_object *)x,"line (%d): %s",linenumber,tmp);
        }
        else {
            rv = 1;
            jerr = JIT_ERR_NONE;
        }
        XML_ParserFree(parser);
    } else jit_object_error((t_object *)x,"jit_xml_document: could not allocate memory for parser");
    
    sysmem_freehandle(texthandle);
    sysfile_close(fh);

out:
    atom_setsym(&a[0], gensym(cname));
    atom_setlong(&a[1], rv);
    // deal with a gimmeback
    return jerr;
}

long jit_xml_document_decode(t_jit_xml_document *x, const char *data, char **outdata)
{
    t_jit_charset_converter *conv;
    t_symbol *srcenc = x->encoding;
    char *cvtbuffer = NULL;
    long cvtbuffersize = 0;
#ifdef MAC_VERSION
    t_symbol *dstenc = ps_macroman;
#else
    t_symbol *dstenc = ps_ms_ansi;
#endif
    t_jit_err err;
    
    *outdata = NULL;

    if (conv = (t_jit_charset_converter *)jit_object_new(ps_jit_charset_converter, srcenc, dstenc)) {
        err = (t_jit_err)jit_object_method(conv, ps_convert, data, strlen(data) + 1, &cvtbuffer, &cvtbuffersize);
        if (!err) {
            *outdata = cvtbuffer;
            return cvtbuffersize;
        }
        jit_object_free(conv);
    }
    return 0;
}

void jit_xml_document_xmlparse_xmldecl(t_jit_xml_document *x, const char *version, const char *encoding, int standalone)
{
    jit_xml_document_createheader(x, gensym((char *)encoding));
}

void jit_xml_document_xmlparse_element_start(t_jit_xml_document *x, const char *el, const char **attr) 
{
    int i;
    t_jit_xml_element *element;
    t_jit_xml_attribute *attribute;
    char *cstr;
    long size;
    
    size = jit_xml_document_decode(x, el, &cstr);
    
    element = jit_xml_document_createelement(x,gensym((char *)cstr));
    jit_xml_node_appendchild((t_jit_xml_node *)x->parsernode,(t_jit_xml_node *)element);
    sysmem_freeptr(cstr);
    
    x->parsernode = (t_jit_xml_node *)element;
    x->parserdepth++;
    //jit_object_post((t_object *)x,"start element %s, depth = %d",element->node.nodename->s_name,x->parserdepth);

    for (i=0;attr[i];i+=2) {
        //jit_object_post((t_object *)x,"attribute %s = %s",attr[i],attr[i+1]);
        size = jit_xml_document_decode(x, attr[i], &cstr);
        attribute = jit_xml_document_createattribute(x,gensym((char *)cstr));
        sysmem_freeptr(cstr);
        
        size = jit_xml_document_decode(x, attr[i + 1], &cstr);
        jit_xml_node_setnodevalasstring((t_jit_xml_node *)attribute,(char *)cstr);
        sysmem_freeptr(cstr);
        
        jit_attr_setlong(attribute,ps_specified,1);
        jit_xml_element_setattributenode(element,attribute);
    }
}

void jit_xml_document_xmlparse_element_end(t_jit_xml_document *x, const char *el) 
{
    //jit_object_post((t_object *)x,"end element %s",el);
    // I don't think we need to do anything here right now aside from perhaps determine if single tag?
    x->parserdepth--;
    if (x->parsernode)
        x->parsernode = x->parsernode->parentnode;
}

void jit_xml_document_xmlparse_default(t_jit_xml_document *x, const char *s, int len)
{
    //char tmp[256];
    
    //strncpy(tmp,s,MIN(255,len));
    //tmp[MIN(256,len)] = 0;
    //jit_object_post((t_object *)x,"default: len=%d,  %s",len,tmp);
}

void jit_xml_document_xmlparse_characterdata(t_jit_xml_document *x, const char *s, int len)
{
    char tmp[4096];
    char *cstr;
    long size;
    
    // could dynamically allocate if necessary
    strncpy(tmp,s,MIN(4095,len));
    tmp[MIN(4095,len)] = 0;

    size = jit_xml_document_decode(x, tmp, &cstr);
        
    if (x->parsernode->nodetype==ps_cdata) {
        //jit_object_post((t_object *)x,"appending to CDATA: %s",tmp);
        jit_xml_charnode_appenddata((t_jit_xml_charnode *)x->parsernode,cstr);
    } else {
        t_jit_xml_text *text=NULL;

        if (x->parsernode->lastchild&&(x->parsernode->lastchild->nodetype==ps_text))
            text = (t_jit_xml_text *)x->parsernode->lastchild;
        if (!text){
            //jit_object_post((t_object *)x,"creating text node for %s containing %s",x->parsernode->nodename->s_name,tmp);
            text = jit_xml_document_createtextnode(x,cstr);
            jit_xml_node_appendchild((t_jit_xml_node *)x->parsernode,(t_jit_xml_node *)text);
        } else {
            //jit_object_post((t_object *)x,"appending to exisiting child text of %s with %s",x->parsernode->nodename->s_name,tmp);
            jit_xml_charnode_appenddata((t_jit_xml_charnode *)text,cstr);
        }
    }
    sysmem_freeptr(cstr);
}

void jit_xml_document_xmlparse_cdata_start(t_jit_xml_document *x)
{
    t_jit_xml_cdata *cdata;

    //jit_object_post((t_object *)x,"cdata start");
    cdata = jit_xml_document_createcdatasection(x,NULL);
    jit_xml_node_appendchild((t_jit_xml_node *)x->parsernode,(t_jit_xml_node *)cdata);

    x->parsernode = (t_jit_xml_node *)cdata;
    x->parserdepth++;
}

void jit_xml_document_xmlparse_cdata_end(t_jit_xml_document *x)
{
    //jit_object_post((t_object *)x,"cdata end");
    x->parserdepth--;
    if (x->parsernode)
        x->parsernode = x->parsernode->parentnode;
}

void jit_xml_document_xmlparse_comment(t_jit_xml_document *x, const char *s)
{
    t_jit_xml_comment *comment;
    char *cstr;
    long size;
    
    size = jit_xml_document_decode(x, s, &cstr);
    
    comment = (t_jit_xml_comment *)jit_xml_document_createcomment(x,(char *)cstr);
    jit_xml_node_appendchild((t_jit_xml_node *)x->parsernode,(t_jit_xml_node *)comment);

    sysmem_freeptr(cstr);
}

void jit_xml_document_xmlparse_doctype_start(t_jit_xml_document *x, const char *s)
{
    // TODO
    //jit_object_post((t_object *)x,"doctype start: %s",tmp);
}

void jit_xml_document_xmlparse_doctype_end(t_jit_xml_document *x)
{
    // TODO
    //jit_object_post((t_object *)x,"doctype end");
}

t_jit_err jit_xml_document_write(t_jit_xml_document *x, t_symbol *s, long ac, t_atom *av)
{
    long i,childcount,position;
    long err;
    char cname[512];
    char tmp[256];
    short path=0;
    long type = 'TEXT';
    t_filehandle fh;
    
    // could see if object already had name/vol and overwrite

    strcpy(cname, "untitled.xml");      
    if (ac && av && av->a_type == A_SYM) {
        strcpy(cname, av->a_w.w_sym->s_name);
    }
    else {
        if (saveasdialog_extended(cname, &path, &type, &type, 1)) {
            //cancelled
            goto out;
        }
    }

    if (err = path_createsysfile(cname, path, type, &fh)) {
        jit_object_error((t_object *)x,"jit_xml_document_write: could not open file %s",cname);
        goto out;
    }
    x->filename = gensym(cname);
    x->path = path;
    
    if (x->hasheader) {
        char tmp[1024];
        long count;

        sprintf(tmp, "<?xml version=\"1.0\" encoding=\"%s\" standalone=\"yes\"?>\n\n", x->encoding->s_name);
        count = strlen(tmp);
        jit_xml_node_encode_and_write((t_jit_xml_node *)x, fh, &count, tmp);        
    }

    if (x->node.childnodes) {
        childcount = jit_linklist_getsize(x->node.childnodes);
        for (i=0;i<childcount;i++) {
            jit_xml_node_write((t_jit_xml_node *)jit_linklist_getindex(x->node.childnodes,i),fh,0);
        }
    }
    sysfile_getpos(fh, &position);
    sysfile_seteof(fh, position);
    sysfile_close(fh);
    
out:
    return JIT_ERR_NONE;
}

// this is inefficient, but works
void jit_xml_node_encode_and_write(t_jit_xml_node *x, t_filehandle fh, long *count, char *data)
{
    t_jit_charset_converter *conv;
    char *cvtbuffer = NULL;
    long cvtbuffersize = 0;
    t_symbol *dstenc;
#ifdef MAC_VERSION
    t_symbol *srcenc = ps_macroman;
#else
    t_symbol *srcenc = ps_ms_ansi;
#endif
    t_jit_err err;
    t_jit_xml_document *doc;
    
    if (!x->ownerdocument)
        doc = (t_jit_xml_document *)x;
    else
        doc = x->ownerdocument;
        
    dstenc = doc->encoding;
    
    if (conv = (t_jit_charset_converter *)jit_object_new(ps_jit_charset_converter, srcenc, dstenc)) {
        err = (t_jit_err)jit_object_method(conv, ps_convert, data, *count, &cvtbuffer, &cvtbuffersize);
        if (!err) {
            long bytecount = cvtbuffersize;
            sysfile_write(fh, &bytecount, cvtbuffer);
            sysmem_freeptr(cvtbuffer);
            *count = bytecount;
        }
        jit_object_free(conv);
    }
}

#ifdef MAC_VERSION
#define ENTITY_quot     '"'
#define ENTITY_amp      '&'
#define ENTITY_lt       '<'
#define ENTITY_gt       '>'
#else
#define ENTITY_quot     34
#define ENTITY_amp      38
#define ENTITY_lt       60
#define ENTITY_gt       62
#endif

char *jit_xml_convert_entities(char *instr, long *len)
{
    char *outstr = NULL, *os = NULL;
    long inlen = *len;
    long outlen = inlen;
    long i;
    char now;
    
    for (i = 0; i < inlen; i++) {
        now = instr[i];
        switch (now) {
            case ENTITY_quot: outlen += 5; break;
            case ENTITY_amp: outlen += 4; break;
            case ENTITY_lt: outlen += 3; break;
            case ENTITY_gt: outlen += 3; break;
            default: break;
        }
    }
    if (outlen != inlen) {
        os = sysmem_newptrclear(outlen + 1);
        outstr = os;
        for (i = 0; i < inlen; i++) {
            now = instr[i];
            switch (now) {
                case ENTITY_quot: strcat(outstr, "&quot;"); outstr += 6; break;
                case ENTITY_amp: strcat(outstr, "&amp;"); outstr += 5; break;
                case ENTITY_lt: strcat(outstr, "&lt;"); outstr += 4; break;
                case ENTITY_gt: strcat(outstr, "&gt;"); outstr += 4; break;
                default: *outstr++ = now; break;
            }
        }
        *len = outlen;
        return os;
    }
    else return NULL;
}

void jit_xml_node_write(t_jit_xml_node *x, t_filehandle fh, long depth)
{
    char tmp[8096],tmp2[8096];
    long i,attrcount,childcount,len,count;
    t_jit_xml_attribute *attr;
    char *p,*p2,*cvt;
    
    if (!x)
        return;
    
    tmp[0] = 0;

    //jit_object_post((t_object *)x,"trying to write: %s",x->nodetype->s_name);
    if (x->nodetype==ps_text) {
    // TODO: support other kinds of formatting 
    // for now, strip whitespace + use tabbed formatting
        p = ((t_jit_xml_charnode *)x)->data;
        len = ((t_jit_xml_charnode *)x)->length;
        // strip leading white space
        while (len&&*p&&((*p=='\r')||(*p=='\n')||(*p=='\t')||(*p==' '))) {
            len--;p++;
        }   
        while (len) {
            tmp[0] = 0;
            for (i=0;i<depth;i++)
                strcat(tmp,"\t");
            count = strlen(tmp);
            jit_xml_node_encode_and_write(x,fh,&count,tmp);
            //move up to any line break
            p2 = p;
            count = 0;
            while ((count<len)&&*p2&&(*p2!='\r')&&(*p2!='\n')) {
                count++;p2++;
            }
            len -= count;               
            jit_xml_node_encode_and_write(x,fh,&count,p);   
            p = p2;
            // write new line
            count = 1;
            jit_xml_node_encode_and_write(x,fh,&count,"\n");
            // strip trailing white space (leading for next line)
            while (len&&*p&&((*p=='\r')||(*p=='\n')||(*p=='\t')||(*p==' '))) {
                len--;p++;
            }   
        }
    } else if (x->nodetype==ps_cdata) {
        for (i=0;i<depth;i++)
            strcat(tmp,"\t");
        strcat(tmp,"<![CDATA[");
        count = strlen(tmp);
        jit_xml_node_encode_and_write(x,fh,&count,tmp);
        
        count = ((t_jit_xml_charnode *)x)->length;
        jit_xml_node_encode_and_write(x,fh,&count,((t_jit_xml_charnode *)x)->data);
        
        tmp[0]=0;
        //for (i=0;i<depth;i++)
        //  strcat(tmp,"\t");
        strcat(tmp,"]]>");
        strcat(tmp,"\n"); //newline, could be native
        count = strlen(tmp);
        jit_xml_node_encode_and_write(x,fh,&count,tmp); 
    } else if (x->nodetype==ps_comment) {
        for (i=0;i<depth;i++)
            strcat(tmp,"\t");
        strcat(tmp,"<!--");
        count = strlen(tmp);
        jit_xml_node_encode_and_write(x,fh,&count,tmp);
        
        count = ((t_jit_xml_charnode *)x)->length;
        jit_xml_node_encode_and_write(x,fh,&count,((t_jit_xml_charnode *)x)->data);
        
        tmp[0]=0;
        //for (i=0;i<depth;i++)
        //  strcat(tmp,"\t");
        strcat(tmp,"-->");
        strcat(tmp,"\n"); //newline, could be native
        count = strlen(tmp);
        jit_xml_node_encode_and_write(x,fh,&count,tmp); 
    } else {
        for (i=0;i<depth;i++)
            strcat(tmp,"\t");
        strcat(tmp,"<");
        strcat(tmp,x->nodename->s_name);
        if (x->attributes) {
            attrcount = jit_linklist_getsize(x->attributes);
            for (i=0;i<attrcount;i++) {
                attr = jit_linklist_getindex(x->attributes,i);
                strcat(tmp," ");
                strcat(tmp,attr->node.nodename->s_name);
                strcat(tmp,"=\"");
                len = 8096;
                p = tmp2;
                jit_xml_node_getnodevalasstring((t_jit_xml_node *)attr,&len,&p);
                if ((cvt = jit_xml_convert_entities(p, &len))) {
                    strcat(tmp, cvt);
                    sysmem_freeptr(cvt);
                } else {
                    strcat(tmp,p);  
                }               
                strcat(tmp,"\"");
            }
        }
        if (x->childnodes)
            childcount = jit_linklist_getsize(x->childnodes);
        else 
            childcount = 0;
        
        if (childcount>0) {
            strcat(tmp,">");
            strcat(tmp,"\n"); //newline, could be native
            count = strlen(tmp);
            jit_xml_node_encode_and_write(x,fh,&count,tmp);
            for (i=0;i<childcount;i++) {
                jit_xml_node_write((t_jit_xml_node *)jit_linklist_getindex(x->childnodes,i),fh,depth+1);
            }   
            tmp[0] = 0;
            for (i=0;i<depth;i++)
                strcat(tmp,"\t");
            sprintf(tmp,"%s</%s>",tmp,x->nodename->s_name);
            strcat(tmp,"\n"); //newline, could be native
            count = strlen(tmp);
            jit_xml_node_encode_and_write(x,fh,&count,tmp);
        } else {
            //singletag
            strcat(tmp," />");
            strcat(tmp,"\n"); //newline, could be native
            count = strlen(tmp);
            jit_xml_node_encode_and_write(x,fh,&count,tmp);
        }
    }   
}

void jit_xml_node_print(t_jit_xml_node *x, long depth)
{
    char tmp[1024],tmp2[1024];
    long i,attrcount,childcount,len;
    t_jit_xml_attribute *attr;
    char *p;
    
    if (!x)
        return;
    
    tmp[0] = 0;
    for (i=0;i<depth;i++)
        strcat(tmp,"    ");
    strcat(tmp,"<");
    strcat(tmp,x->nodename->s_name);
    if (x->attributes) {
        attrcount = jit_linklist_getsize(x->attributes);
        for (i=0;i<attrcount;i++) {
            attr = jit_linklist_getindex(x->attributes,i);
            strcat(tmp," ");
            strcat(tmp,attr->node.nodename->s_name);
            strcat(tmp,"=\"");
            len = 1024;
            p = tmp2;
            jit_xml_node_getnodevalasstring((t_jit_xml_node *)attr,&len,&p);
            strcat(tmp,p);
            strcat(tmp,"\"");
        }
    }
    if (x->childnodes)
        childcount = jit_linklist_getsize(x->childnodes);
    else 
        childcount = 0;
    
    if (childcount>0) {
        strcat(tmp,">");
        jit_object_post((t_object *)x,tmp);
        for (i=0;i<childcount;i++) {
            jit_xml_node_print((t_jit_xml_node *)jit_linklist_getindex(x->childnodes,i),depth+1);
        }   
        tmp[0] = 0;
        for (i=0;i<depth;i++)
            strcat(tmp,"    ");
        jit_object_post((t_object *)x,"%s</%s>",tmp,x->nodename->s_name);
    } else {
        //singletag
        strcat(tmp," />");
        jit_object_post((t_object *)x,tmp);
    }
}

void jit_xml_document_print(t_jit_xml_document *x)
{
    long i,childcount;
    
    if (x->node.childnodes) {
        childcount = jit_linklist_getsize(x->node.childnodes);
        for (i=0;i<childcount;i++) {
            jit_xml_node_print((t_jit_xml_node *)jit_linklist_getindex(x->node.childnodes,i),0);
        }
    }
}

void jit_xml_document_createheader(t_jit_xml_document *x, t_symbol *encoding)
{
    if (encoding == ps_utf_8 ||
        encoding == ps_utf_16 ||
        encoding == ps_iso_8859_1 ||
        encoding == ps_us_ascii)
    {
        x->hasheader = true;
        x->encoding = encoding;
    } else {
        x->hasheader = false;
        x->encoding = ps_utf_8;
    }
}

t_jit_xml_element *jit_xml_document_createelement(t_jit_xml_document *x, t_symbol *tagname)
{
    t_jit_xml_element *element;
    
    element = jit_object_new(gensym("jit_xml_element"));
    element->node.nodename = tagname;
    element->node.ownerdocument = x;

    return element;
}

t_jit_xml_text *jit_xml_document_createtextnode(t_jit_xml_document *x, char *data)
{
    t_jit_xml_text *text;

    text = jit_object_new(gensym("jit_xml_text"));
    if (data)
        jit_xml_charnode_replacedata((t_jit_xml_charnode *)text,0,strlen(data),data);
    text->charnode.node.ownerdocument = x;

    return text;
}

t_jit_xml_comment *jit_xml_document_createcomment(t_jit_xml_document *x, char *data)
{
    t_jit_xml_comment *comment;

    comment = jit_object_new(gensym("jit_xml_comment"));
    if (data)
        jit_xml_charnode_replacedata((t_jit_xml_charnode *)comment,0,strlen(data),data);
    comment->charnode.node.ownerdocument = x;

    return comment;
}

t_jit_xml_cdata *jit_xml_document_createcdatasection(t_jit_xml_document *x, char *data)
{
    t_jit_xml_cdata *cdata;

    cdata = jit_object_new(gensym("jit_xml_cdata"));
    if (data)
        jit_xml_charnode_replacedata((t_jit_xml_charnode *)cdata,0,strlen(data),data);
    cdata->charnode.node.ownerdocument = x;

    return cdata;
}

t_jit_xml_attribute *jit_xml_document_createattribute(t_jit_xml_document *x, t_symbol *name)
{
    t_jit_xml_attribute *attribute;
    
    attribute = jit_object_new(gensym("jit_xml_attribute"));
    attribute->node.nodename = name;
    attribute->node.ownerdocument = x;
    
    return attribute;
}

t_jit_linklist *jit_xml_document_getelementsbytagname(t_jit_xml_document *x, t_symbol *tagname)
{
    
    t_jit_linklist *elements=NULL;
    // depthfirst (preorder) traversal  
    jit_xml_node_getelementsbytagname_helper((t_jit_xml_node *)x,tagname,&elements);
    return elements;            
}

void *jit_xml_document_new(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_xml_document *x;

    if (x = (t_jit_xml_document *)object_alloc(_jit_xml_document_class)) {
        jit_xml_node_new((t_jit_xml_node *)x,ps_document);
        x->filename = _jit_sym_nothing;
        x->path = 0;
        x->parserdepth = 0;
        x->parsernode = NULL;   
        x->hasheader = false;
        x->encoding = ps_utf_8;
    }

    return x;
}

void jit_xml_document_free(t_jit_xml_document *x)
{
    jit_xml_node_free((t_jit_xml_node *)x);
}


/*------------------------------------------------------------------------------
    jit_xml_element
-------------------------------------------------------------------------------*/

//  jit_class_addmethod(c,(method)jit_xml_element_normalize,                "normalize",                A_CANT, 0); //todo

t_jit_err jit_xml_element_getattribute(t_jit_xml_element *x, t_symbol *attrname, long *ac, t_atom **av)
{
    t_jit_xml_attribute *attr=NULL;
    
    if (x&&x->node.attributes) {
        jit_linklist_findfirst(x->node.attributes,(void **)&attr,(t_cmpfn)jit_xml_attr_symcompare,attrname);
        if (attr) {
            return object_attr_getvalueof(attr,ps_nodevalue,ac,av);
        }
    }
    return JIT_ERR_GENERIC;         
}

t_jit_err jit_xml_element_setattribute(t_jit_xml_element *x, t_symbol *attrname, long ac, t_atom *av)
{
    t_jit_xml_attribute *attr=NULL;
    
    if (x) {
        if (!x->node.attributes)
            x->node.attributes = jit_linklist_new();
        jit_linklist_findfirst(x->node.attributes,(void **)&attr,(t_cmpfn)jit_xml_attr_symcompare,attrname);
        if (attr) {
            return object_attr_setvalueof(attr,ps_nodevalue,ac,av);
        } else {
            attr = jit_xml_document_createattribute(x->node.ownerdocument,attrname);
            object_attr_setvalueof((t_jit_xml_node *)attr,ps_nodevalue,ac,av);
            jit_xml_element_setattributenode(x,attr);
        }
    }
    return JIT_ERR_GENERIC;         
}

t_jit_err jit_xml_element_removeattribute(t_jit_xml_element *x, t_symbol *attrname)
{
    t_jit_xml_attribute *attr=NULL;
    long i;
    
    jit_linklist_findfirst(x->node.attributes,(void **)&attr,(t_cmpfn)jit_xml_attr_symcompare,attrname);
    if (attr) {
        i = jit_linklist_objptr2index(x->node.attributes,(t_jit_object *)attr);
        if (i>=0) {
            jit_linklist_deleteindex(x->node.attributes,i);
            return JIT_ERR_NONE;
        }
    }
    return JIT_ERR_GENERIC;         
}

t_jit_xml_attribute *jit_xml_element_getattributenode(t_jit_xml_element *x, t_symbol *attrname)
{
    t_jit_xml_attribute *attr=NULL;
    
    if (x&&x->node.attributes)
        jit_linklist_findfirst(x->node.attributes,(void **)&attr,(t_cmpfn)jit_xml_attr_symcompare,attrname);
    return attr;            
}

t_jit_xml_attribute *jit_xml_element_setattributenode(t_jit_xml_element *x, t_jit_xml_attribute *attr)
{
    t_jit_xml_attribute *oldattr=NULL;
    long i;
    
    if (!x->node.attributes)
        x->node.attributes = jit_linklist_new();
    jit_linklist_findfirst(x->node.attributes,(void **)&oldattr,(t_cmpfn)jit_xml_attr_symcompare,attr->node.nodename);
    if (oldattr) {
        i = jit_linklist_objptr2index(x->node.attributes,(t_jit_object *)attr);
        if (i>=0) {
            jit_linklist_deleteindex(x->node.attributes,i);
        }
    } 
    jit_linklist_append(x->node.attributes,attr);
    return NULL; // we free the node, not the caller as the DOM spec suggests           
}

t_jit_xml_attribute * jit_xml_element_removeattributenode(t_jit_xml_element *x, t_jit_xml_attribute *attr)
{
    t_jit_xml_attribute *oldattr=NULL;
    long i;
    
    if (x&&x->node.attributes) {
        jit_linklist_findfirst(x->node.attributes,(void **)&oldattr,(t_cmpfn)jit_xml_attr_symcompare,attr->node.nodename);
        if (oldattr) {
            i = jit_linklist_objptr2index(x->node.attributes,(t_jit_object *)oldattr);
            if (i>=0) {
                jit_linklist_deleteindex(x->node.attributes,i);
            }
        }
    }
    return NULL; // we free the node, not the caller as the DOM spec suggests           
}

t_jit_linklist *jit_xml_element_getelementsbytagname(t_jit_xml_element *x, t_symbol *tagname)
{
    
    t_jit_linklist *elements=NULL;
    // depthfirst (preorder) traversal  
    jit_xml_node_getelementsbytagname_helper((t_jit_xml_node *)x,tagname,&elements);
    return elements;            
}


long jit_xml_element_symcompare(t_jit_xml_attribute *x,t_symbol *name)
{
    return (name&&(x->node.nodename==name));
}

void *jit_xml_element_new(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_xml_element *x;

    if (x = (t_jit_xml_element *)object_alloc(_jit_xml_element_class)) {
        jit_xml_node_new((t_jit_xml_node *)x,ps_element);
        x->singletag = 0; // yes???
    }

    return x;
}

void jit_xml_element_free(t_jit_xml_element *x)
{
    jit_xml_node_free((t_jit_xml_node *)x);
}

// utils
t_symbol *jit_xml_element_getattribute_sym(t_jit_xml_element *x, t_symbol *attrname)
{
    long        ac=0;
    t_atom      *av=NULL;
    t_symbol    *rv=_jit_sym_nothing;
    
    if (x&&attrname) {
        if (((jit_xml_element_getattribute(x,attrname,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getsym(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_xml_element_setattribute_sym(t_jit_xml_element *x, t_symbol *attrname, t_symbol *s)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x&&attrname) {      
        jit_atom_setsym(av,s);
        rv = jit_xml_element_setattribute(x,attrname,ac,av);
    }
    return rv;
}

long jit_xml_element_getattribute_long(t_jit_xml_element *x, t_symbol *attrname)
{
    long        ac=0;
    t_atom      *av=NULL;
    long        rv=0;
    
    if (x&&attrname) {
        if (((jit_xml_element_getattribute(x,attrname,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getlong(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_xml_element_setattribute_long(t_jit_xml_element *x, t_symbol *attrname, long c)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x&&attrname) {      
        jit_atom_setlong(av,c);
        rv = jit_xml_element_setattribute(x,attrname,ac,av);
    }
    return rv;
}


float jit_xml_element_getattribute_float(t_jit_xml_element *x, t_symbol *attrname)
{
    long        ac=0;
    t_atom      *av=NULL;
    float       rv=0;
    
    if (x&&attrname) {
        if (((jit_xml_element_getattribute(x,attrname,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                rv = jit_atom_getfloat(av);
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return rv;
}

t_jit_err jit_xml_element_setattribute_float(t_jit_xml_element *x, t_symbol *attrname, float f)
{
    long        ac=1;
    t_atom      av[1];
    t_jit_err   rv=JIT_ERR_GENERIC;
    
    if (x&&attrname) {      
        jit_atom_setfloat(av,f);
        rv = jit_xml_element_setattribute(x,attrname,ac,av);
    }
    return rv;
}

long jit_xml_element_getattribute_sym_array(t_jit_xml_element *x, t_symbol *attrname, long max, t_symbol **vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    
    if (x&&attrname&&vals) {
        if (((jit_xml_element_getattribute(x,attrname,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getsym(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_xml_element_setattribute_sym_array(void *x, t_symbol *attrname, long count, t_symbol **vals)
{
    t_atom      av[XML_MAX_ATOM_COUNT];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&attrname&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setsym(av+i,vals[i]);
        rv = jit_xml_element_setattribute(x,attrname,count,av);
    }
    return rv;
}

long jit_xml_element_getattribute_long_array(t_jit_xml_element *x, t_symbol *attrname, long max, long *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    
    if (x&&attrname&&vals) {
        if (((jit_xml_element_getattribute(x,attrname,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getlong(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_xml_element_setattribute_long_array(void *x, t_symbol *attrname, long count, long *vals)
{
    t_atom      av[XML_MAX_ATOM_COUNT];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&attrname&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setlong(av+i,vals[i]);
        rv = jit_xml_element_setattribute(x,attrname,count,av);
    }
    return rv;
}

long jit_xml_element_getattribute_float_array(t_jit_xml_element *x, t_symbol *attrname, long max, float *vals)
{
    long        i,ac=0;
    t_atom      *av=NULL;
    
    if (x&&attrname&&vals) {
        if (((jit_xml_element_getattribute(x,attrname,&ac,&av))==JIT_ERR_NONE)&&av) {
            if (ac&&av) {
                max = MIN(max,ac);
                for (i=0;i<max;i++) {
                    vals[i]=jit_atom_getfloat(av+i);
                }
                jit_freebytes(av,sizeof(t_atom)*ac);
            }
        }       
    }
    return ac;
}

t_jit_err jit_xml_element_setattribute_float_array(void *x, t_symbol *attrname, long count, float *vals)
{
    t_atom      av[XML_MAX_ATOM_COUNT];
    t_jit_err   rv=JIT_ERR_GENERIC;
    long        i;
    
    if (x&&attrname&&vals) {
        for (i=0;i<count;i++)
            jit_atom_setfloat(av+i,vals[i]);
        rv = jit_xml_element_setattribute(x,attrname,count,av);
    }
    return rv;
}


/*------------------------------------------------------------------------------
    jit_xml_attribute
-------------------------------------------------------------------------------*/

long jit_xml_attr_symcompare(t_jit_xml_attribute *x,t_symbol *name)
{
    return (name&&(x->node.nodename==name));
}

void *jit_xml_attribute_new(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_xml_attribute *x;

    if (x = (t_jit_xml_attribute *)object_alloc(_jit_xml_attribute_class)) {
        jit_xml_node_new((t_jit_xml_node *)x,ps_attribute);
        x->specified = 0;   
    }

    return x;
}

void jit_xml_attribute_free(t_jit_xml_attribute *x)
{
    jit_xml_node_free((t_jit_xml_node *)x);
}

/*------------------------------------------------------------------------------
    jit_xml_text
-------------------------------------------------------------------------------*/

void *jit_xml_text_new(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_xml_text *x;

    if (x = (t_jit_xml_text *)object_alloc(_jit_xml_text_class)) {
        jit_xml_charnode_new((t_jit_xml_charnode *)x,ps_text);
    }

    return x;
}

t_jit_xml_text *jit_xml_text_splittext(t_jit_xml_text *x, long offset)
{
    // TODO
    return NULL;
}

void jit_xml_text_free(t_jit_xml_text *x)
{
    jit_xml_charnode_free((t_jit_xml_charnode *)x);
}

/*------------------------------------------------------------------------------
    jit_xml_comment
-------------------------------------------------------------------------------*/


void *jit_xml_comment_new(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_xml_comment *x;

    if (x = (t_jit_xml_comment *)object_alloc(_jit_xml_comment_class)) {
        jit_xml_charnode_new((t_jit_xml_charnode *)x,ps_comment);
    }

    return x;
}

void jit_xml_comment_free(t_jit_xml_comment *x)
{
    jit_xml_charnode_free((t_jit_xml_charnode *)x);
}


/*------------------------------------------------------------------------------
    jit_xml_cdata
-------------------------------------------------------------------------------*/


void *jit_xml_cdata_new(t_symbol *s, long argc, t_atom *argv)
{
    t_jit_xml_cdata *x;

    if (x = (t_jit_xml_cdata *)object_alloc(_jit_xml_cdata_class)) {
        jit_xml_charnode_new((t_jit_xml_charnode *)x,ps_cdata);
    }

    return x;
}

t_jit_xml_cdata *jit_xml_cdata_splittext(t_jit_xml_cdata *x, long offset)
{
    // TODO
    return NULL;
}

void jit_xml_cdata_free(t_jit_xml_cdata *x)
{
    jit_xml_charnode_free((t_jit_xml_charnode *)x);
}

Copyright © 2008, Cycling '74