Make build work without libmba and domcHEADmaster

1 files changed, 526 insertions, 0 deletions

diff --git a/src/dom.h b/src/dom.h
new file mode 100644
index 0000000..b439d60
--- /dev/null
+++ b/src/dom.h
@@ -0,0 +1,526 @@
+/* DOMC Document Object Model library in C
+ * Copyright (c) 2001 Michael B. Allen <mba2000 ioplex.com>
+ *
+ * The MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* dom.h - internal interfaces
+ */
+
+#ifndef DOM_H
+#define DOM_H
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <time.h>
+
+struct msgno_entry {
+	int msgno;
+	const char *msg;
+};
+
+const char *msgno_msg(int msgno);
+
+extern struct msgno_entry dom_codes[];
+
+#if defined(__sparc__)
+  #include <sys/inttypes.h>
+#elif defined(_WIN32)
+  typedef unsigned __int64 uint64_t;
+#else
+  #include <stdint.h>
+#endif
+
+/* Enable this for hashing and fast access to large child node lists */
+#define FAST_NODELIST 0
+
+#if FAST_NODELIST
+#include <mba/hashmap.h>
+#endif
+
+/* DOM_String
+ */
+
+typedef char DOM_String;
+
+/* DOM_TimeStamp - Introduced in DOM Level 2
+ */
+
+typedef uint64_t DOM_TimeStamp;
+
+/* DOM_Exception
+ */
+
+extern int *_DOM_Exception(void);
+
+#define DOM_Exception (*_DOM_Exception())
+
+/* DOM_EventException - Introduced in DOM Level 2
+ */
+
+#define DOM_UNSPECIFIED_EVENT_TYPE_ERR  dom_codes[13].msgno
+
+/* DOM_Node
+ */
+
+typedef struct DOM_Node DOM_Node;
+typedef struct DOM_NodeList DOM_NodeList;
+typedef struct DOM_NodeList DOM_NamedNodeMap;
+typedef struct NodeEntry NodeEntry;
+
+typedef DOM_Node DOM_Attr;
+typedef DOM_Node DOM_Element;
+typedef DOM_Node DOM_CharacterData;
+typedef DOM_CharacterData DOM_Text;
+typedef DOM_CharacterData DOM_Comment;
+typedef DOM_Text DOM_CDATASection;
+typedef DOM_Node DOM_DocumentType;
+typedef DOM_Node DOM_Notation;
+typedef DOM_Node DOM_Entity;
+typedef DOM_Node DOM_EntityReference;
+typedef DOM_Node DOM_ProcessingInstruction;
+typedef DOM_Node DOM_DocumentFragment;
+typedef DOM_Node DOM_Document;
+typedef DOM_Document DOM_DocumentLS;
+/* Introduced in DOM Level 2: */
+typedef DOM_Node DOM_EventTarget;
+typedef struct ListenerEntry ListenerEntry;
+typedef DOM_Document DOM_DocumentEvent;
+typedef DOM_Document DOM_AbstractView;
+typedef DOM_Document DOM_DocumentView;
+
+#define DOM_ELEMENT_NODE                1
+#define DOM_ATTRIBUTE_NODE              2
+#define DOM_TEXT_NODE                   3
+#define DOM_CDATA_SECTION_NODE          4
+#define DOM_ENTITY_REFERENCE_NODE       5
+#define DOM_ENTITY_NODE                 6
+#define DOM_PROCESSING_INSTRUCTION_NODE 7
+#define DOM_COMMENT_NODE                8
+#define DOM_DOCUMENT_NODE               9
+#define DOM_DOCUMENT_TYPE_NODE          10
+#define DOM_DOCUMENT_FRAGMENT_NODE      11
+#define DOM_NOTATION_NODE               12
+
+/* events forward references - Introduced in DOM Level 2
+ */
+
+typedef struct DOM_Event DOM_Event;
+typedef struct DOM_Event DOM_UIEvent;
+typedef DOM_UIEvent DOM_TextEvent;
+typedef struct DOM_Event DOM_MutationEvent;
+
+typedef void DOM_EventListener;
+typedef void (*DOM_EventListener_handleEvent)(DOM_EventListener *this, DOM_Event *evt);
+
+struct ListenerEntry {
+	DOM_String *type;
+	DOM_EventListener *listener;
+	DOM_EventListener_handleEvent listener_fn;
+	int useCapture;
+};
+
+struct DOM_Node {
+    DOM_String *nodeName;
+    DOM_String *nodeValue;
+    unsigned short nodeType;
+    DOM_Node *parentNode;
+    DOM_NodeList *childNodes;
+    DOM_Node *firstChild;
+    DOM_Node *lastChild;
+    DOM_Node *previousSibling;
+    DOM_Node *nextSibling;
+    DOM_NamedNodeMap *attributes;
+    DOM_Document *ownerDocument;
+	/* Custom Fields */
+	unsigned int listeners_len;
+	ListenerEntry **listeners;
+	unsigned short subtreeModified;
+    union {
+        struct {
+            DOM_DocumentType *doctype;
+            DOM_Element *documentElement;
+			DOM_DocumentView *document;
+			DOM_AbstractView *defaultView;
+			DOM_Node *commonParent;
+			DOM_String *version;
+			DOM_String *encoding;
+			int standalone;
+        } Document;
+        struct {
+            DOM_String *name;
+            DOM_NamedNodeMap *entities;
+            DOM_NamedNodeMap *notations;
+			DOM_String *publicId;
+			DOM_String *systemId;
+			DOM_String *internalSubset;
+        } DocumentType;
+        struct {
+            DOM_String *tagName;
+        } Element;
+        struct {
+            DOM_String *name;
+            int specified;
+            DOM_String *value;
+			DOM_Element *ownerElement;
+        } Attr;
+        struct {
+            DOM_String *data;
+            int length;
+        } CharacterData;
+        struct {
+            DOM_String *publicId;
+            DOM_String *systemId;
+        } Notation;
+       struct {
+            DOM_String *publicId;
+            DOM_String *systemId;
+            DOM_String *notationName;
+        } Entity;
+        struct {
+            DOM_String *target;
+            DOM_String *data;
+        } ProcessingInstruction;
+    } u;
+    unsigned int rtfxRefCount;          /* Reference counting added for RTFX */
+    void* userData;                     /* User data added for RTFX */
+};
+
+DOM_Node *DOM_Node_insertBefore(DOM_Node *node, DOM_Node *newChild, DOM_Node *refChild);
+DOM_Node *DOM_Node_replaceChild(DOM_Node *node, DOM_Node *newChild, DOM_Node *oldChild);
+DOM_Node *DOM_Node_removeChild(DOM_Node *node, DOM_Node *oldChild);
+DOM_Node *DOM_Node_appendChild(DOM_Node *node, DOM_Node *newChild);
+int DOM_Node_hasChildNodes(const DOM_Node *node);
+DOM_Node *DOM_Node_cloneNode(DOM_Node *node, int deep);
+DOM_String *DOM_Node_getNodeValue(DOM_Node *node);
+void DOM_Node_setNodeValue(DOM_Node *node, DOM_String *value);
+
+/* DOM_NodeList, DOM_NamedNodeMap
+ */
+
+struct NodeEntry {
+	NodeEntry *prev;
+	NodeEntry *next;
+	DOM_Node *node;
+};
+struct DOM_NodeList {
+    DOM_Document *_ownerDocument;
+	DOM_Element *_ownerElement;
+	int length;
+	NodeEntry *first;
+	NodeEntry *last;
+	unsigned short filter;
+	struct DOM_NodeList *list; /* Used for entities and notations */
+#if FAST_NODELIST
+	struct hashmap* _map;
+#endif
+    unsigned int rtfxRefCount; /* Reference counting added for RTFX */
+};
+
+DOM_Node *DOM_NodeList_item(const DOM_NodeList *nl, int index);
+
+DOM_Node *DOM_NamedNodeMap_getNamedItem(const DOM_NamedNodeMap *map, const DOM_String *name);
+DOM_Node *DOM_NamedNodeMap_setNamedItem(DOM_NamedNodeMap *map, DOM_Node *arg);
+DOM_Node *DOM_NamedNodeMap_removeNamedItem(DOM_NamedNodeMap *map, const DOM_String *name);
+DOM_Node *DOM_NamedNodeMap_item(const DOM_NamedNodeMap *map, int index);
+
+/* DOM_Implementation
+ */
+
+int DOM_Implementation_hasFeature(DOM_String *feature, DOM_String *version);
+DOM_DocumentType *DOM_Implementation_createDocumentType(DOM_String *qualifiedName,
+										DOM_String *publicId, DOM_String *systemId);
+DOM_Document *DOM_Implementation_createDocument(DOM_String *namespaceURI,
+										DOM_String *qualifiedName, DOM_DocumentType *doctype);
+
+/* DOM_Element
+ */
+
+DOM_String *DOM_Element_getAttribute(const DOM_Element *element, const DOM_String *name);
+void DOM_Element_setAttribute(DOM_Element *element, const DOM_String *name,
+										const DOM_String *value);
+void DOM_Element_removeAttribute(DOM_Element *element, const DOM_String *name);
+DOM_Attr *DOM_Element_getAttributeNode(const DOM_Element *element, const DOM_String *name);
+DOM_Attr *DOM_Element_setAttributeNode(DOM_Element *element, DOM_Attr *newAttr);
+DOM_Attr *DOM_Element_removeAttributeNode(DOM_Element *element, DOM_Attr *oldAttr);
+DOM_NodeList *DOM_Element_getElementsByTagName(DOM_Element *element, const DOM_String *name);
+void DOM_Element_normalize(DOM_Element *element);
+
+/* DOM_CharacterData
+ */
+
+DOM_String *DOM_CharacterData_substringData(DOM_CharacterData *data,
+										int offset, int count);
+void DOM_CharacterData_appendData(DOM_CharacterData *data, const DOM_String *arg);
+void DOM_CharacterData_insertData(DOM_CharacterData *data, int offset,
+										const DOM_String *arg);
+void DOM_CharacterData_deleteData(DOM_CharacterData *data, int offset, int count);
+void DOM_CharacterData_replaceData(DOM_CharacterData *data, int offset, int count,
+                                        const DOM_String *arg);
+int DOM_CharacterData_getLength(DOM_CharacterData *data);
+
+/* DOM_Text
+ */
+
+DOM_Text *DOM_Text_splitText(DOM_Text *text, int offset);
+
+/* DOM_Document
+ */
+
+DOM_Element *DOM_Document_createElement(DOM_Document *doc, const DOM_String *tagName);
+DOM_DocumentFragment *DOM_Document_createDocumentFragment(DOM_Document *doc);
+DOM_Text *DOM_Document_createTextNode(DOM_Document *doc, const DOM_String *data);
+DOM_Comment *DOM_Document_createComment(DOM_Document *doc, const DOM_String *data);
+DOM_CDATASection *DOM_Document_createCDATASection(DOM_Document *doc, const DOM_String *data);
+DOM_ProcessingInstruction *DOM_Document_createProcessingInstruction(DOM_Document *doc,
+										const DOM_String *target, const DOM_String *data);
+DOM_Attr *DOM_Document_createAttribute(DOM_Document *doc, const DOM_String *name);
+DOM_EntityReference *DOM_Document_createEntityReference(DOM_Document *doc,
+										const DOM_String *name);
+DOM_NodeList *DOM_Document_getElementsByTagName(DOM_Document *doc, const DOM_String *tagname);
+
+void DOM_Document_destroyNode(DOM_Document *doc, DOM_Node *node);
+void DOM_Document_destroyNodeList(DOM_Document *doc, DOM_NodeList *nl, int free_nodes);
+
+DOM_DocumentType *DOM_Document_getDoctype(DOM_Document *doc);
+DOM_Element *DOM_Document_getDocumentElement(DOM_Document *doc);
+
+/* DOM_DocumentLS - This does NOT resemble the Load/Save interfaces
+ * described in the latest W3C drafts at all.
+ */
+
+int DOM_DocumentLS_save(DOM_DocumentLS *this, const char *uri, const DOM_Node *node);
+int DOM_DocumentLS_fwrite(const DOM_DocumentLS *this, FILE *stream);
+
+/* Events - Introduced in DOM Level 2
+ * http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html
+ */
+
+/* DOM_Event - Introduced in DOM Level 2
+ */
+
+#define DOM_EVENT_CAPTURING_PHASE 1
+#define DOM_EVENT_AT_TARGET       2
+#define DOM_EVENT_BUBBLING_PHASE  3
+
+struct DOM_Event {
+	const DOM_String *type;
+	DOM_EventTarget *target;
+	DOM_EventTarget *currentTarget;
+	unsigned short eventPhase;
+	int bubbles;
+	int cancelable;
+	DOM_TimeStamp timeStamp;
+/* custom -- do not touch */
+	int _pd;
+	int _sp;
+	unsigned int _modifiers;
+/* UIEvent members */
+	DOM_AbstractView *view;
+	long detail;
+/* TextEvent members */
+	DOM_String *outputString;
+	unsigned long keyVal;
+	unsigned long virtKeyVal;
+	int visibleOutputGenerated;
+	int numPad;
+/* MutationEvent members */
+	DOM_Node *relatedNode;
+	DOM_String *prevValue;
+	DOM_String *newValue;
+	DOM_String *attrName;
+	unsigned short attrChange;
+};
+
+void DOM_Event_stopPropagation(DOM_Event *evt);
+void DOM_Event_preventDefault(DOM_Event *evt);
+void DOM_Event_initEvent(DOM_Event *evt, const DOM_String *eventTypeArg,
+								int canBubbleArg, int cancelableArg);
+
+/* DOM_DocumentEvent - Introduced in DOM Level 2
+ */
+
+DOM_Event *DOM_DocumentEvent_createEvent(DOM_DocumentEvent *doc,
+								const DOM_String *eventType);
+void DOM_DocumentEvent_destroyEvent(DOM_DocumentEvent *doc, DOM_Event *evt);
+
+/* DOM_UIEvent
+ */
+
+void DOM_UIEvent_initUIEvent(DOM_UIEvent *evt,
+								const DOM_String *typeArg,
+								int canBubbleArg,
+								int cancelableArg,
+								DOM_AbstractView *viewArg,
+								long detailArg);
+
+/* DOM_EventTarget - Introduced in DOM Level 2
+ */
+
+void DOM_EventTarget_addEventListener(DOM_EventTarget *target,
+								const DOM_String *type,
+								DOM_EventListener *listener,
+								DOM_EventListener_handleEvent listener_fn,
+								int useCapture);
+void DOM_EventTarget_removeEventListener(DOM_EventTarget *target,
+								const DOM_String *type,
+								DOM_EventListener *listener,
+								DOM_EventListener_handleEvent listener_fn,
+								int useCapture);
+int DOM_EventTarget_dispatchEvent(DOM_EventTarget *target, DOM_Event *evt);
+
+/* DOM_TextEvent - Introduced in DOM Level 3
+ * http://www.w3.org/TR/2002/WD-DOM-Level-3-Events-20020208/events.html
+ */
+
+#define DOM_VK_UNDEFINED     0x0
+#define DOM_VK_RIGHT_ALT     0x01
+#define DOM_VK_LEFT_ALT      0x02
+#define DOM_VK_LEFT_CONTROL  0x03
+#define DOM_VK_RIGHT_CONTROL 0x04
+#define DOM_VK_LEFT_SHIFT    0x05
+#define DOM_VK_RIGHT_SHIFT   0x06
+#define DOM_VK_LEFT_META     0x07
+#define DOM_VK_RIGHT_META    0x08
+#define DOM_VK_CAPS_LOCK     0x09
+#define DOM_VK_DELETE        0x0A
+#define DOM_VK_END           0x0B
+#define DOM_VK_ENTER         0x0C
+#define DOM_VK_ESCAPE        0x0D
+#define DOM_VK_HOME          0x0E
+#define DOM_VK_INSERT        0x0F
+#define DOM_VK_NUM_LOCK      0x10
+#define DOM_VK_PAUSE         0x11
+#define DOM_VK_PRINTSCREEN   0x12
+#define DOM_VK_SCROLL_LOCK   0x13
+#define DOM_VK_LEFT          0x14
+#define DOM_VK_RIGHT         0x15
+#define DOM_VK_UP            0x16
+#define DOM_VK_DOWN          0x17
+#define DOM_VK_PAGE_DOWN     0x18
+#define DOM_VK_PAGE_UP       0x19
+#define DOM_VK_F1            0x1A
+#define DOM_VK_F2            0x1B
+#define DOM_VK_F3            0x1C
+#define DOM_VK_F4            0x1D
+#define DOM_VK_F5            0x1E
+#define DOM_VK_F6            0x1F
+#define DOM_VK_F7            0x20
+#define DOM_VK_F8            0x21
+#define DOM_VK_F9            0x22
+#define DOM_VK_F10           0x23
+#define DOM_VK_F11           0x24
+#define DOM_VK_F12           0x25
+#define DOM_VK_F13           0x26
+#define DOM_VK_F14           0x27
+#define DOM_VK_F15           0x28
+#define DOM_VK_F16           0x29
+#define DOM_VK_F17           0x2A
+#define DOM_VK_F18           0x2B
+#define DOM_VK_F19           0x2C
+#define DOM_VK_F20           0x2D
+#define DOM_VK_F21           0x2E
+#define DOM_VK_F22           0x2F
+#define DOM_VK_F23           0x30
+#define DOM_VK_F24           0x31
+
+int DOM_TextEvent_checkModifier(DOM_TextEvent *evt, unsigned int modifier);
+void DOM_TextEvent_initTextEvent(DOM_TextEvent *evt, const DOM_String *typeArg,
+										int canBubbleArg, int cancelableArg,
+										DOM_AbstractView *viewArg, long detailArg,
+										DOM_String *outputStringArg,
+										unsigned int keyValArg,
+										unsigned int virtKeyValArg,
+										int visibleOutputGeneratedArg,
+										int numPadArg);
+void DOM_TextEvent_initModifier(DOM_TextEvent *evt, unsigned int modifier, int value);
+
+/* Useful X KeySym to keyVal and virtKeyVal conversion functions
+ * Add these .o's to the OBJS line in the Makefile to compile
+ */
+
+unsigned int keysym2ucs(unsigned short keysym);
+unsigned int keysym2domvk(unsigned short keysym);
+
+/* MutationEvent
+ */
+
+#define DOM_MUTATION_EVENT_MODIFICATION 1
+#define DOM_MUTATION_EVENT_ADDITION     2
+#define DOM_MUTATION_EVENT_REMOVAL      3
+
+void DOM_MutationEvent_initMutationEvent(DOM_MutationEvent *evt,
+										DOM_String *typeArg,
+										int canBubbleArg,
+										int cancelableArg,
+										DOM_Node *relatedNodeArg,
+										DOM_String *prevValueArg,
+										DOM_String *newValueArg,
+										DOM_String *attrNameArg,
+										unsigned short attrChangeArg);
+void DOM_MutationEvent_processSubtreeModified(DOM_EventTarget *subtree);
+
+/* Temporary Functions
+ */
+
+void DOM_Node_printNode(DOM_Node *node);
+void DOM_Node_printNode2(DOM_Node *node);
+
+#define DOM_INDEX_SIZE_ERR              dom_codes[0].msgno
+#define DOM_DOMSTRING_SIZE_ERR          dom_codes[1].msgno
+#define DOM_HIERARCHY_REQUEST_ERR       dom_codes[2].msgno
+#define DOM_WRONG_DOCUMENT_ERR          dom_codes[3].msgno
+#define DOM_INVALID_CHARACTER_ERR       dom_codes[4].msgno
+#define DOM_NO_DATA_ALLOWED_ERR         dom_codes[5].msgno
+#define DOM_NO_MODIFICATION_ALLOWED_ERR dom_codes[6].msgno
+#define DOM_NOT_FOUND_ERR               dom_codes[7].msgno
+#define DOM_NOT_SUPPORTED_ERR           dom_codes[8].msgno
+#define DOM_INUSE_ATTRIBUTE_ERR         dom_codes[9].msgno
+#define DOM_XML_PARSER_ERR              dom_codes[10].msgno
+#define DOM_CREATE_FAILED               dom_codes[11].msgno
+#define DOM_CHARACTER_ENC_ERR           dom_codes[12].msgno
+#define DOM_UNSPECIFIED_EVENT_TYPE_ERR  dom_codes[13].msgno
+#define DOM_FILTERED_LIST_ERR           dom_codes[14].msgno
+
+#define CANNOT_HAVE_CHILD_OF(p, c) !(child_matrix[(p)->nodeType - 1] & \
+					(1 << ((c)->nodeType - 1)))
+#define MODIFYING_DOC_ELEM(p, c) ((p)->nodeType == DOM_DOCUMENT_NODE && \
+					(c)->nodeType == DOM_ELEMENT_NODE)
+#define MODIFYING_DOCTYPE_ELEM(p, c) ((p)->nodeType == DOM_DOCUMENT_NODE && \
+					(c)->nodeType == DOM_DOCUMENT_TYPE_NODE)
+#define INVALID_HIER_REQ(p, c) (CANNOT_HAVE_CHILD_OF(p, c) || \
+					(MODIFYING_DOC_ELEM(p, c) && (p)->u.Document.documentElement))
+
+extern unsigned short child_matrix[];
+
+DOM_NodeList *Document_createNodeList(DOM_Document *doc);
+DOM_Node *NodeList_itemFiltered(const DOM_NodeList *list, int index, unsigned short nodeType);
+NodeEntry *NodeList_insert(DOM_NodeList *nl, DOM_Node *newChild, DOM_Node *refChild);
+NodeEntry *NodeList_replace(DOM_NodeList *nl, DOM_Node *newChild, DOM_Node *oldChild);
+NodeEntry *NodeList_remove(DOM_NodeList *nl, DOM_Node *oldChild);
+NodeEntry *NodeList_append(DOM_NodeList *nl, DOM_Node *newChild);
+int NodeList_exists(DOM_NodeList *nl, DOM_Node *child);
+
+DOM_NamedNodeMap *Document_createNamedNodeMap(DOM_Document *doc);
+
+#endif /* DOM_H */