summaryrefslogtreecommitdiff
path: root/src/core/document_type.c
blob: fc1a1e92215c1fe1760f9c0bad590c42964967e1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
/*
 * This file is part of libdom.
 * Licensed under the MIT License,
 *                http://www.opensource.org/licenses/mit-license.php
 * Copyright 2007 John-Mark Bell <jmb@netsurf-browser.org>
 * Copyright 2007 James Shaw <jshaw@netsurf-browser.org>
 */

#include <dom/core/document_type.h>
#include <dom/core/string.h>
#include <dom/bootstrap/implpriv.h>

#include "core/document_type.h"
#include "core/node.h"
#include "utils/utils.h"

/**
 * DOM DocumentType node
 */
struct dom_document_type {
	struct dom_node_internal base;		/**< Base node */

	/** \todo other members */
	struct dom_string *public_id;	/**< Doctype public ID */
	struct dom_string *system_id;	/**< Doctype system ID */

	dom_alloc alloc;		/**< Memory (de)allocation function */
	void *pw;			/**< Pointer to private data */
};

static struct dom_document_type_vtable document_type_vtable = {
	{
		DOM_NODE_VTABLE	
	},
	DOM_DOCUMENT_TYPE_VTABLE
};

/**
 * Create a document type node
 *
 * \param qname      The qualified name of the document type
 * \param public_id  The external subset public identifier
 * \param system_id  The external subset system identifier
 * \param alloc      Memory (de)allocation function
 * \param pw         Pointer to client-specific private data
 * \param doctype    Pointer to location to receive result
 * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion.
 *
 * The doctype will be referenced, so the client need not do so
 * explicitly. The client must unref the doctype once it has
 * finished with it.
 */
dom_exception dom_document_type_create(struct dom_string *qname,
		struct dom_string *public_id, struct dom_string *system_id,
		dom_alloc alloc, void *pw, struct dom_document_type **doctype)
{
	struct dom_document_type *result;
	dom_exception err;

	/* Create node */
	result = alloc(NULL, sizeof(struct dom_document_type), pw);
	if (result == NULL)
		return DOM_NO_MEM_ERR;

	/* Initialise base node */
	err = dom_node_initialise(&result->base, NULL, DOM_DOCUMENT_TYPE_NODE,
			qname, NULL, NULL, NULL);
	if (err != DOM_NO_ERR) {
		alloc(result, 0, pw);
		return err;
	}

	/* Initialise the vtable */
	result->base.base.vtable = &document_type_vtable;
	result->base.destroy = &dom_document_type_destroy;

	/* Get public and system IDs */
	dom_string_ref(public_id);
	result->public_id = public_id;

	dom_string_ref(system_id);
	result->system_id = system_id;

	/* Fill in allocation information */
	result->alloc = alloc;
	result->pw = pw;

	*doctype = result;

	return DOM_NO_ERR;
}

/**
 * Destroy a DocumentType node
 *
 * \param doctype  The DocumentType node to destroy
 *
 * The contents of ::doctype will be destroyed and ::doctype will be freed.
 */
void dom_document_type_destroy(struct dom_node_internal *doctypenode)
{
	struct dom_document_type *doctype = 
			(struct dom_document_type *)doctypenode;

	/* Finish with public and system IDs */
	dom_string_unref(doctype->system_id);
	dom_string_unref(doctype->public_id);

	/* Finalise base class */
	dom_node_finalise(doctype->base.owner, &doctype->base);

	/* Free doctype */
	doctype->alloc(doctype, 0, doctype->pw);
}

/**
 * Retrieve a document type's name
 *
 * \param doc_type  Document type to retrieve name from
 * \param result    Pointer to location to receive result
 * \return DOM_NO_ERR.
 *
 * The returned string will have its reference count increased. It is
 * the responsibility of the caller to unref the string once it has
 * finished with it.
 */
dom_exception _dom_document_type_get_name(struct dom_document_type *doc_type,
		struct dom_string **result)
{
	UNUSED(doc_type);
	UNUSED(result);

	return DOM_NOT_SUPPORTED_ERR;
}

/**
 * Retrieve a document type's entities
 *
 * \param doc_type  Document type to retrieve entities from
 * \param result    Pointer to location to receive result
 * \return DOM_NO_ERR.
 *
 * The returned map will have its reference count increased. It is
 * the responsibility of the caller to unref the map once it has
 * finished with it.
 */
dom_exception _dom_document_type_get_entities(
		struct dom_document_type *doc_type,
		struct dom_namednodemap **result)
{
	UNUSED(doc_type);
	UNUSED(result);

	return DOM_NOT_SUPPORTED_ERR;
}

/**
 * Retrieve a document type's notations
 *
 * \param doc_type  Document type to retrieve notations from
 * \param result    Pointer to location to receive result
 * \return DOM_NO_ERR.
 *
 * The returned map will have its reference count increased. It is
 * the responsibility of the caller to unref the map once it has
 * finished with it.
 */
dom_exception _dom_document_type_get_notations(
		struct dom_document_type *doc_type,
		struct dom_namednodemap **result)
{
	UNUSED(doc_type);
	UNUSED(result);

	return DOM_NOT_SUPPORTED_ERR;
}

/**
 * Retrieve a document type's public id
 *
 * \param doc_type  Document type to retrieve public id from
 * \param result    Pointer to location to receive result
 * \return DOM_NO_ERR.
 *
 * The returned string will have its reference count increased. It is
 * the responsibility of the caller to unref the string once it has
 * finished with it.
 */
dom_exception _dom_document_type_get_public_id(
		struct dom_document_type *doc_type,
		struct dom_string **result)
{
	UNUSED(doc_type);
	UNUSED(result);

	return DOM_NOT_SUPPORTED_ERR;
}

/**
 * Retrieve a document type's system id
 *
 * \param doc_type  Document type to retrieve system id from
 * \param result    Pointer to location to receive result
 * \return DOM_NO_ERR.
 *
 * The returned string will have its reference count increased. It is
 * the responsibility of the caller to unref the string once it has
 * finished with it.
 */
dom_exception _dom_document_type_get_system_id(
		struct dom_document_type *doc_type,
		struct dom_string **result)
{
	UNUSED(doc_type);
	UNUSED(result);

	return DOM_NOT_SUPPORTED_ERR;
}

/**
 * Retrieve a document type's internal subset
 *
 * \param doc_type  Document type to retrieve internal subset from
 * \param result    Pointer to location to receive result
 * \return DOM_NO_ERR.
 *
 * The returned string will have its reference count increased. It is
 * the responsibility of the caller to unref the string once it has
 * finished with it.
 */
dom_exception _dom_document_type_get_internal_subset(
		struct dom_document_type *doc_type,
		struct dom_string **result)
{
	UNUSED(doc_type);
	UNUSED(result);

	return DOM_NOT_SUPPORTED_ERR;
}