Annotation of parser3/src/classes/xdoc.C, revision 1.207
1.1 parser 1: /** @file
1.2 parser 2: Parser: @b xdoc parser class.
1.1 parser 3:
1.207 ! moko 4: Copyright (c) 2001-2026 Art. Lebedev Studio (https://www.artlebedev.com)
1.202 moko 5: Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
1.96 paf 6: */
1.1 parser 7:
1.111 paf 8: #include "pa_config_includes.h"
9:
1.1 parser 10: #ifdef XML
1.96 paf 11:
1.69 paf 12: #include "libxml/tree.h"
1.133 paf 13: #include "libxml/HTMLtree.h"
1.69 paf 14: #include "libxslt/xsltInternals.h"
15: #include "libxslt/transform.h"
16: #include "libxslt/xsltutils.h"
1.90 paf 17: #include "libxslt/variables.h"
1.132 paf 18: #include "libxslt/imports.h"
1.111 paf 19:
20: #include "pa_vmethod_frame.h"
21:
22: #include "pa_stylesheet_manager.h"
23: #include "pa_request.h"
24: #include "pa_vxdoc.h"
25: #include "pa_charset.h"
26: #include "pa_vfile.h"
1.115 paf 27: #include "pa_xml_exception.h"
1.111 paf 28: #include "xnode.h"
1.171 misha 29: #include "pa_charsets.h"
1.111 paf 30:
1.207 ! moko 31: volatile const char * IDENT_XDOC_C="$Id: xdoc.C,v 1.206 2024/12/06 23:20:04 moko Exp $";
1.173 moko 32:
1.1 parser 33: // defines
34:
35: #define XDOC_CLASS_NAME "xdoc"
36:
37: // class
38:
1.111 paf 39: class MXdoc: public MXnode {
1.1 parser 40: public: // VStateless_class
1.164 misha 41: Value* create_new_value(Pool&) { return new VXdoc(); }
1.1 parser 42:
43: public:
1.111 paf 44: MXdoc();
1.1 parser 45:
46: };
47:
1.111 paf 48: // global variable
49:
1.186 moko 50: DECLARE_CLASS_VAR(xnode, new MXnode); // must be here as Xdoc is inherited from Xnode and should be inited before
1.184 moko 51: DECLARE_CLASS_VAR(xdoc, new MXdoc);
1.61 paf 52:
1.138 paf 53: // helper classes
54:
55: class xmlOutputBuffer_auto_ptr {
56: public:
57: explicit xmlOutputBuffer_auto_ptr(xmlOutputBuffer *_APtr = 0)
58: : _Owns(_APtr != 0), _Ptr(_APtr) {}
59: xmlOutputBuffer_auto_ptr(const xmlOutputBuffer_auto_ptr& _Y)
60: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
61: xmlOutputBuffer_auto_ptr& operator=(const xmlOutputBuffer_auto_ptr& _Y)
62: {if (this != &_Y)
63: {if (_Ptr != _Y.get())
64: {if (_Owns && _Ptr)
65: xmlOutputBufferClose(_Ptr);
66: _Owns = _Y._Owns; }
67: else if (_Y._Owns)
68: _Owns = true;
69: _Ptr = _Y.release(); }
70: return (*this); }
71: ~xmlOutputBuffer_auto_ptr()
72: {if (_Owns && _Ptr)
73: xmlOutputBufferClose(_Ptr); }
74: xmlOutputBuffer& operator*() const
75: {return (*get()); }
76: xmlOutputBuffer *operator->() const
77: {return (get()); }
78: xmlOutputBuffer *get() const
79: {return (_Ptr); }
80: xmlOutputBuffer *release() const
81: {((xmlOutputBuffer_auto_ptr *)this)->_Owns = false;
82: return (_Ptr); }
83: private:
84: bool _Owns;
85: xmlOutputBuffer *_Ptr;
86: };
87:
1.65 paf 88: class xsltTransformContext_auto_ptr {
89: public:
1.67 paf 90: explicit xsltTransformContext_auto_ptr(xsltTransformContext *_APtr = 0)
91: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.65 paf 92: xsltTransformContext_auto_ptr(const xsltTransformContext_auto_ptr& _Y)
93: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
94: xsltTransformContext_auto_ptr& operator=(const xsltTransformContext_auto_ptr& _Y)
95: {if (this != &_Y)
96: {if (_Ptr != _Y.get())
97: {if (_Owns && _Ptr)
98: xsltFreeTransformContext(_Ptr);
99: _Owns = _Y._Owns; }
100: else if (_Y._Owns)
101: _Owns = true;
102: _Ptr = _Y.release(); }
103: return (*this); }
104: ~xsltTransformContext_auto_ptr()
105: {if (_Owns && _Ptr)
106: xsltFreeTransformContext(_Ptr); }
107: xsltTransformContext& operator*() const
108: {return (*get()); }
109: xsltTransformContext *operator->() const
110: {return (get()); }
111: xsltTransformContext *get() const
112: {return (_Ptr); }
113: xsltTransformContext *release() const
114: {((xsltTransformContext_auto_ptr *)this)->_Owns = false;
115: return (_Ptr); }
116: private:
117: bool _Owns;
118: xsltTransformContext *_Ptr;
119: };
1.61 paf 120:
1.1 parser 121: // methods
122:
1.149 paf 123: static void writeNode(Request& r, VXdoc& xdoc, xmlNode* node) {
124: if(!node)
1.154 misha 125: throw Exception(PARSER_RUNTIME,
1.149 paf 126: 0,
127: "error creating node"); // OOM, bad name, things like that
1.54 paf 128:
129: // write out result
1.190 moko 130: r.write(xdoc.wrap(*node));
1.149 paf 131: }
132:
133: struct IdsIteratorInfo {
134: xmlChar *elementId;
135: xmlNode *element;
136: };
137:
1.196 moko 138: /* switching to calling convetion of libxml */
139: extern "C" void idsHashScanner (void *payload, void *data, const xmlChar *name) {
1.149 paf 140: IdsIteratorInfo *priv = (IdsIteratorInfo *)data;
141:
142: if (priv->element == NULL && xmlStrEqual (name, priv->elementId))
143: {
144: xmlNode* parent=((xmlID *)payload)->attr->parent;
145: assert(parent);
146: priv->element=parent;
147: }
148: }
149:
1.196 moko 150: static xmlNode* pa_getElementById(xmlDoc& xmldoc, xmlChar* elementId) {
1.149 paf 151: xmlHashTable *ids = (xmlHashTable *)xmldoc.ids;
152: IdsIteratorInfo iter={elementId, NULL};
1.196 moko 153: xmlHashScan(ids, (xmlHashScanner)idsHashScanner, &iter);
1.149 paf 154: return iter.element;
155: }
156:
157: /*
158: static xmlNode *
159: pa_importNode (xmlDoc& xmldoc, xmlNode& importedNode, bool deep) {
160: xmlNode *result = NULL;
161:
162: switch (importedNode.type) {
163: case XML_ATTRIBUTE_NODE:
164: result = (xmlNode *)xmlCopyProp(xmldoc, (xmlAttr *)importedNode);
165: result.parent=0; // no idea
166: break;
167: case XML_DOCUMENT_FRAG_NODE:
168: case XML_ELEMENT_NODE:
169: case XML_ENTITY_REF_NODE:
170: case XML_PI_NODE:
171: case XML_TEXT_NODE:
172: case XML_CDATA_SECTION_NODE:
173: case XML_COMMENT_NODE:
174: result = xmlCopyNode (importedNode->n, deep);
175: xmlSetTreeDoc (result, priv->n);
176: break;
177: default:
178: *exc = GDOME_NOT_SUPPORTED_ERR;
179: }
180:
181: return result;
1.54 paf 182: }
1.149 paf 183: */
1.54 paf 184:
1.16 parser 185: // Element createElement(in DOMString tagName) raises(DOMException);
1.111 paf 186: static void _createElement(Request& r, MethodParams& params) {
1.168 misha 187: xmlChar* tagName=as_xmlname(r, params, 0, "tagName must be string");
188:
1.111 paf 189: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 190: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 191:
1.149 paf 192: xmlNode *node=xmlNewDocNode(&xmldoc, NULL, tagName, NULL);
193: writeNode(r, vdoc, node);
1.16 parser 194: }
195:
1.113 paf 196: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 197: static void _createElementNS(Request& r, MethodParams& params) {
1.168 misha 198: xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
199: xmlChar* qualifiedName=as_xmlqname(r, params, 1);
200:
1.112 paf 201: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 202: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 203:
1.149 paf 204: xmlChar* prefix=0;
205: xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
1.112 paf 206:
1.149 paf 207: xmlNode *node;
208: if(localName) {
209: xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
210: node=xmlNewDocNode(&xmldoc, &ns, localName, NULL);
211: } else
212: node=xmlNewDocNode(&xmldoc, NULL, qualifiedName/*unqualified, actually*/, NULL);
213: writeNode(r, vdoc, node);
1.112 paf 214: }
215:
1.16 parser 216: // DocumentFragment createDocumentFragment()
1.111 paf 217: static void _createDocumentFragment(Request& r, MethodParams&) {
218: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 219: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 220:
1.149 paf 221: xmlNode *node=xmlNewDocFragment(&xmldoc);
222: writeNode(r, vdoc, node);
1.16 parser 223: }
224:
225: // Text createTextNode(in DOMString data);
1.111 paf 226: static void _createTextNode(Request& r, MethodParams& params) {
1.168 misha 227: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
228:
1.111 paf 229: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 230: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 231:
1.149 paf 232: xmlNode *node=xmlNewDocText(&xmldoc, data);
233: writeNode(r, vdoc, node);
1.16 parser 234: }
235:
236: // Comment createComment(in DOMString data)
1.111 paf 237: static void _createComment(Request& r, MethodParams& params) {
1.168 misha 238: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
239:
1.111 paf 240: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.16 parser 241:
1.149 paf 242: xmlNode *node=xmlNewComment(data);
243: writeNode(r, vdoc, node);
1.16 parser 244: }
245:
246: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
1.111 paf 247: static void _createCDATASection(Request& r, MethodParams& params) {
1.168 misha 248: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
249:
1.111 paf 250: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 251: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 252:
1.149 paf 253: xmlNode *node=xmlNewCDataBlock(&xmldoc, data, strlen((const char*)data));
254: writeNode(r, vdoc, node);
1.16 parser 255: }
256:
257: // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
1.111 paf 258: static void _createProcessingInstruction(Request& r, MethodParams& params) {
1.168 misha 259: xmlChar* target=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
260: xmlChar* data=as_xmlchar(r, params, 1, XML_DATA_MUST_BE_STRING);
261:
1.111 paf 262: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 263: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 264:
1.149 paf 265: xmlNode *node=xmlNewDocPI(&xmldoc, target, data);
266: writeNode(r, vdoc, node);
1.16 parser 267: }
268:
269: // Attr createAttribute(in DOMString name) raises(DOMException);
1.111 paf 270: static void _createAttribute(Request& r, MethodParams& params) {
1.168 misha 271: xmlChar* name=as_xmlname(r, params, 0);
272:
1.111 paf 273: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 274: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 275:
1.149 paf 276: xmlNode *node=(xmlNode*)xmlNewDocProp(&xmldoc, name, 0);
277: writeNode(r, vdoc, node);
1.16 parser 278: }
1.112 paf 279:
1.113 paf 280: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 281: static void _createAttributeNS(Request& r, MethodParams& params) {
1.168 misha 282: xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
283: xmlChar* qualifiedName=as_xmlqname(r, params, 1);
284:
1.112 paf 285: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 286: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 287:
1.149 paf 288: xmlChar* prefix=0;
289: xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
290:
291: xmlNode *node;
292: if(localName) {
293: xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
294: node=(xmlNode*)xmlNewDocProp(&xmldoc, localName, NULL);
295: xmlSetNs(node, &ns);
296: } else
297: node=(xmlNode*)xmlNewDocProp(&xmldoc, qualifiedName/*unqualified, actually*/, NULL);
298: writeNode(r, vdoc, node);
1.112 paf 299: }
300:
1.16 parser 301: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
1.111 paf 302: static void _createEntityReference(Request& r, MethodParams& params) {
1.168 misha 303: xmlChar* name=as_xmlname(r, params, 0);
304:
1.111 paf 305: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 306: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 307:
1.149 paf 308: xmlNode *node=xmlNewReference(&xmldoc, name);
309: writeNode(r, vdoc, node);
1.99 paf 310: }
311:
312:
1.111 paf 313: static void _getElementById(Request& r, MethodParams& params) {
1.168 misha 314: xmlChar* elementId=as_xmlname(r, params, 0, "elementID must be string");
315:
1.111 paf 316: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 317: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 318:
1.168 misha 319: if(xmlNode *node=pa_getElementById(xmldoc, elementId))
1.149 paf 320: writeNode(r, vdoc, node);
1.54 paf 321: }
1.79 paf 322:
1.111 paf 323: static void _importNode(Request& r, MethodParams& params) {
1.168 misha 324: xmlNode& importedNode=as_node(params, 0, "importedNode must be node");
325: bool deep=params.as_bool(1, "deep must be bool", r);
326:
1.111 paf 327: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 328: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.79 paf 329:
1.149 paf 330: xmlNode *node=xmlDocCopyNode(&importedNode, &xmldoc, deep?1: 0);
331: writeNode(r, vdoc, node);
1.79 paf 332: }
1.168 misha 333:
1.195 moko 334: #define XML_PARSE_OPTIONS (XML_PARSE_DTDLOAD | XML_PARSE_NOENT | XML_PARSE_HUGE)
1.1 parser 335:
1.111 paf 336: static void _create(Request& r, MethodParams& params) {
337: Charset& source_charset=r.charsets.source();
338: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 339:
1.111 paf 340: Value& param=params[params.count()-1];
1.149 paf 341: xmlDoc* xmldoc;
1.111 paf 342: bool set_encoding=false;
1.95 paf 343: if(param.get_junction()) { // {<?xml?>...}
1.189 moko 344:
1.91 paf 345: const String& xml=r.process_to_string(param);
1.189 moko 346: String::Body sbody=xml.cstr_to_string_body_untaint(String::L_XML, r.connection(false), &r.charsets);
1.83 paf 347:
1.195 moko 348: xmldoc=xmlReadMemory(sbody.cstr(), sbody.length(), NULL, NULL, XML_PARSE_OPTIONS);
1.163 misha 349:
1.149 paf 350: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 351: throw XmlException(0, r);
1.111 paf 352:
353: // must be last action in if, see after if}
1.149 paf 354: } else { // [localName]
1.153 misha 355: if(const String* value = param.get_string()){
356: xmlChar* localName=r.transcode(*value);
1.168 misha 357: if(xmlValidateNCName(localName, 0) != 0)
358: throw XmlException(0, XML_INVALID_LOCAL_NAME, localName);
359:
1.151 misha 360: xmldoc=xmlNewDoc(0);
361: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 362: throw XmlException(0, r);
1.168 misha 363:
1.151 misha 364: xmlNode* node=xmlNewChild((xmlNode*)xmldoc, NULL, localName, NULL);
365: if(!node || xmlHaveGenericErrors())
1.179 moko 366: throw XmlException(0, r);
1.103 paf 367:
1.151 misha 368: set_encoding=true;
369: // must be last action in if, see after if}
1.153 misha 370: } else {
1.201 moko 371: VFile* vfile=param.as_vfile();
1.195 moko 372: xmldoc=xmlReadMemory(vfile->value_ptr(), vfile->value_size(), NULL, NULL, XML_PARSE_OPTIONS);
1.153 misha 373: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 374: throw XmlException(0, r);
1.151 misha 375: }
1.111 paf 376: }
377: // must be first action after if}
378: // replace any previous parsed source
1.149 paf 379: vdoc.set_xmldoc(r.charsets, *xmldoc);
1.95 paf 380:
381: // URI
1.111 paf 382: const char* URI_cstr;
383: if(params.count()>1) { // absolute(param)
384: const String& URI=params.as_string(0, "URI must be string");
1.197 moko 385: URI_cstr=r.full_disk_path(URI).cstr();
1.95 paf 386: } else // default = disk path to requested document
1.111 paf 387: URI_cstr=r.request_info.path_translated;
1.95 paf 388: if(URI_cstr)
1.149 paf 389: xmldoc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
1.95 paf 390:
1.111 paf 391: if(set_encoding) {
392: const char* source_charset_name=source_charset.NAME().cstr();
1.149 paf 393: xmldoc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
1.111 paf 394: }
1.9 parser 395: }
396:
1.111 paf 397: static void _load(Request& r, MethodParams& params) {
398: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.9 parser 399:
1.54 paf 400: // filespec
1.156 misha 401: const String* uri=¶ms.as_string(0, "URI must be string");
1.122 paf 402: const char* uri_cstr;
403: if(uri->pos("://")==STRING_NOT_FOUND) // disk path
1.197 moko 404: uri_cstr=r.full_disk_path(*uri).taint_cstr(String::L_FILE_SPEC);
1.122 paf 405: else // xxx://
1.162 misha 406: uri_cstr=uri->taint_cstr(String::L_AS_IS); // leave as-is for xmlParseFile to handle
1.105 paf 407:
1.157 misha 408: /// @todo!! add SAFE MODE!!
1.195 moko 409: xmlDoc* xmldoc=xmlReadFile(uri_cstr, NULL, XML_PARSE_OPTIONS);
1.149 paf 410: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 411: throw XmlException(uri, r);
1.149 paf 412:
1.111 paf 413: // must be first action after if}
414: // replace any previous parsed source
1.149 paf 415: vdoc.set_xmldoc(r.charsets, *xmldoc);
1.9 parser 416: }
417:
1.166 misha 418: String::C xdoc2buf(Request& r, VXdoc& vdoc,
419: XDocOutputOptions& oo,
420: const String* file_spec,
421: bool use_source_charset_to_render_and_client_charset_to_write_to_header=false) {
1.171 misha 422: Charset* render=0;
423: Charset* header=0;
1.140 paf 424: if(use_source_charset_to_render_and_client_charset_to_write_to_header) {
1.171 misha 425: render=&r.charsets.source();
426: header=&r.charsets.client();
1.140 paf 427: } else {
1.188 moko 428: header=render=&pa_charsets.get(*oo.encoding);
1.140 paf 429: }
1.171 misha 430: const char* render_encoding=render->NAME_CSTR();
431: const char* header_encoding=header->NAME_CSTR();
1.140 paf 432:
433: xmlCharEncodingHandler *renderer=xmlFindCharEncodingHandler(render_encoding);
434: // UTF-8 renderer contains empty input/output converters,
1.61 paf 435: // which is wrong for xmlOutputBufferCreateIO
1.140 paf 436: // while zero renderer goes perfectly
1.171 misha 437: if(render->isUTF8())
1.140 paf 438: renderer=0;
1.61 paf 439:
1.140 paf 440: xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer));
1.138 paf 441:
1.199 moko 442: xsltStylesheet *stylesheet = xsltNewStylesheet();
443: if(!stylesheet)
444: throw Exception(0, 0, "xsltNewStylesheet failed");
1.61 paf 445:
1.143 paf 446: #define OOSTRING2STYLE(name) \
1.149 paf 447: stylesheet->name=oo.name?BAD_CAST xmlMemStrdup((const char*)r.transcode(*oo.name)):0
1.143 paf 448: #define OOBOOL2STYLE(name) \
449: if(oo.name>=0) stylesheet->name=oo.name
1.61 paf 450:
1.143 paf 451: OOSTRING2STYLE(method);
452: OOSTRING2STYLE(encoding);
453: OOSTRING2STYLE(mediaType);
454: // OOSTRING2STYLE(doctypeSystem);
455: // OOSTRING2STYLE(doctypePublic);
456: OOBOOL2STYLE(indent);
457: OOSTRING2STYLE(version);
458: OOBOOL2STYLE(standalone);
459: OOBOOL2STYLE(omitXmlDeclaration);
1.61 paf 460:
1.149 paf 461: xmlDoc& xmldoc=vdoc.get_xmldoc();
462: xmldoc.encoding=BAD_CAST xmlMemStrdup(render_encoding);
1.142 paf 463: if(header_encoding)
464: stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding);
1.199 moko 465: if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet)<0
1.149 paf 466: || xmlHaveGenericErrors())
1.179 moko 467: throw XmlException(0, r);
1.61 paf 468:
1.138 paf 469: // write out result
1.166 misha 470: char *gnome_str;
471: size_t gnome_length;
1.180 moko 472: #ifdef LIBXML2_NEW_BUFFER
473: if(outputBuffer->conv) {
474: gnome_length=xmlBufUse(outputBuffer->conv);
475: gnome_str=(char *)xmlBufContent(outputBuffer->conv);
476: } else {
477: gnome_length=xmlOutputBufferGetSize(&(*outputBuffer));
478: gnome_str=(char *)xmlOutputBufferGetContent(&(*outputBuffer));
479: }
480: #else
1.138 paf 481: if(outputBuffer->conv) {
482: gnome_length=outputBuffer->conv->use;
483: gnome_str=(char *)outputBuffer->conv->content;
484: } else {
485: gnome_length=outputBuffer->buffer->use;
486: gnome_str=(char *)outputBuffer->buffer->content;
487: }
1.180 moko 488: #endif
1.138 paf 489:
1.166 misha 490: if(file_spec){
1.165 misha 491: file_write(r.charsets,
492: *file_spec,
493: gnome_str,
494: gnome_length,
1.111 paf 495: true/*as_text*/);
1.166 misha 496: return String::C(); // actually, we don't need this output at all
497: } else
498: return String::C(gnome_length ? pa_strdup(gnome_str, gnome_length) : 0, gnome_length);
499: }
1.111 paf 500:
1.166 misha 501: inline HashStringValue* get_options(MethodParams& params, size_t index){
502: return (params.count()>index) ? params.as_hash(index) : 0;
1.1 parser 503: }
504:
1.111 paf 505: static void _file(Request& r, MethodParams& params) {
506: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 507:
1.177 moko 508: XDocOutputOptions oo(vdoc.output_options);
509: oo.append(r, get_options(params, 0), true/* $.name[filename] could be specified by user */);
1.166 misha 510: String::C buf=xdoc2buf(r, vdoc, oo, 0/*file_name. not to file, to memory*/);
511:
1.111 paf 512: VFile& vfile=*new VFile;
513: VHash& vhcontent_type=*new VHash;
1.182 moko 514: vhcontent_type.hash().put(value_name, new VString(*oo.mediaType));
515: vhcontent_type.hash().put("charset", new VString(*oo.encoding));
1.111 paf 516:
1.176 moko 517: vfile.set_binary(false/*not tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length, oo.filename, &vhcontent_type);
1.169 misha 518:
1.166 misha 519: // write out result
1.190 moko 520: r.write(vfile);
1.63 paf 521: }
522:
1.111 paf 523: static void _save(Request& r, MethodParams& params) {
524: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.63 paf 525:
1.206 moko 526: const String& file_spec=r.full_disk_path(params.as_file_name(0));
1.63 paf 527:
1.177 moko 528: XDocOutputOptions oo(vdoc.output_options);
529: oo.append(r, get_options(params, 1));
1.166 misha 530: xdoc2buf(r, vdoc, oo, &file_spec);
1.63 paf 531: }
532:
1.111 paf 533: static void _string(Request& r, MethodParams& params) {
534: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.166 misha 535:
1.177 moko 536: XDocOutputOptions oo(vdoc.output_options);
537: oo.append(r, get_options(params, 0));
1.166 misha 538: String::C buf=xdoc2buf(r, vdoc, oo,
539: 0/*file_name. not to file, to memory*/,
1.140 paf 540: true/*use source charset to render, client charset to put to header*/);
1.166 misha 541:
1.63 paf 542: // write out result
1.190 moko 543: r.write(String(buf, String::L_AS_IS));
1.1 parser 544: }
1.58 paf 545:
1.111 paf 546: #ifndef DOXYGEN
547: struct Add_xslt_param_info {
548: Request* r;
1.149 paf 549: Array<const xmlChar*>* strings;
550: const xmlChar** current_transform_param;
1.111 paf 551: };
552: #endif
553: static void add_xslt_param(
554: HashStringValue::key_type attribute,
555: HashStringValue::value_type meaning,
556: Add_xslt_param_info* info) {
1.149 paf 557: xmlChar* s;
558: *info->current_transform_param++=(s=info->r->transcode(attribute)); *info->strings+=s;
559: *info->current_transform_param++=(s=info->r->transcode(meaning->as_string())); *info->strings+=s;
1.111 paf 560: }
1.132 paf 561:
1.199 moko 562: static VXdoc& _transform(Request& r, const String* stylesheet_source, VXdoc& vdoc, xsltStylesheetPtr stylesheet, const xmlChar** transform_params)
1.132 paf 563: {
1.149 paf 564: xmlDoc& xmldoc=vdoc.get_xmldoc();
565:
1.65 paf 566: xsltTransformContext_auto_ptr transformContext(
1.149 paf 567: xsltNewTransformContext(stylesheet, &xmldoc));
1.90 paf 568: // make params literal
1.111 paf 569: if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
1.90 paf 570: transformContext->globalVars = xmlHashCreate(20);
1.149 paf 571: xsltQuoteUserParams(transformContext.get(), (const char**)transform_params);
1.90 paf 572: // do transform
1.59 paf 573: xmlDoc *transformed=xsltApplyStylesheetUser(
574: stylesheet,
1.149 paf 575: &xmldoc,
1.90 paf 576: 0/*already quoted-inserted transform_params*/,
1.111 paf 577: 0/*const char* output*/,
1.59 paf 578: 0/*FILE *profile*/,
1.65 paf 579: transformContext.get());
1.149 paf 580: if(!transformed || xmlHaveGenericErrors())
1.179 moko 581: throw XmlException(stylesheet_source, r);
1.42 paf 582:
1.61 paf 583: //gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing
584: transformed->type=XML_DOCUMENT_NODE;
1.177 moko 585: // constructing result
586: VXdoc& result=*new VXdoc(r.charsets, *transformed);
587: /* grabbing options
588:
589: <xsl:output
590: !method = "xml" | "html" | "text"
591: X| qname-but-not-ncname
592: !version = nmtoken
593: !encoding = string
594: !omit-xml-declaration = "yes" | "no"
595: !standalone = "yes" | "no"
596: !doctype-public = string
597: !doctype-system = string
598: Xcdata-section-elements = qnames
599: !indent = "yes" | "no"
600: !media-type = string />
601: */
602: XDocOutputOptions& oo=result.output_options;
603:
604: oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
605: oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
606: oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
607: oo.indent=stylesheet->indent;
608: oo.version=stylesheet->version?&r.transcode(stylesheet->version):0;
609: oo.standalone=stylesheet->standalone;
610: oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration;
1.167 misha 611:
1.177 moko 612: // return
613: return result;
1.93 paf 614: }
1.111 paf 615: static void _transform(Request& r, MethodParams& params) {
616: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.93 paf 617:
618: // params
1.149 paf 619: Array<const xmlChar*> transform_strings;
620: const xmlChar** transform_params=0;
1.166 misha 621: if(params.count()>1)
1.174 misha 622: if(HashStringValue* hash=params.as_hash(1, "transform options")) {
1.193 moko 623: transform_params=new(PointerGC) const xmlChar*[hash->count()*2+1];
1.166 misha 624: Add_xslt_param_info info={
625: &r,
626: &transform_strings,
627: transform_params
628: };
629: hash->for_each<Add_xslt_param_info*>(add_xslt_param, &info);
630: transform_params[hash->count()*2]=0;
631: }
1.93 paf 632:
1.111 paf 633: VXdoc* result;
1.203 moko 634: if(VXdoc *vxdoc=dynamic_cast<VXdoc*>(¶ms[0])) { // stylesheet (xdoc)
635: xmlDoc& stylesheetdoc=vxdoc->get_xmldoc();
1.191 moko 636:
1.199 moko 637: // compile xdoc stylesheet
638: xsltStylesheet *stylesheet=xsltParseStylesheetDoc(&stylesheetdoc);
639: if(xmlHaveGenericErrors())
640: throw XmlException(0, r);
641: if(!stylesheet)
642: throw Exception("xml", 0, "stylesheet failed to compile");
1.93 paf 643:
644: // transform!
1.199 moko 645: result=&_transform(r, 0, vdoc, stylesheet, transform_params);
1.93 paf 646: } else { // stylesheet (file name)
647: // extablish stylesheet connection
1.197 moko 648: const String& stylesheet_filespec=r.full_disk_path(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
1.198 moko 649: Stylesheet_connection_ptr connection(stylesheet_manager->get_connection(stylesheet_filespec));
1.93 paf 650:
651: // load and compile file to stylesheet [or get cached if any]
652: // transform!
1.191 moko 653: result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(), transform_params);
1.93 paf 654: }
655:
1.59 paf 656: // write out result
1.190 moko 657: r.write(*result);
1.1 parser 658: }
659:
1.16 parser 660: // constructor
1.2 parser 661:
1.92 paf 662: /// @test how to create empty type html?
1.185 moko 663: MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME) {
664: set_base(xnode_class);
665:
1.16 parser 666: /// DOM1
1.2 parser 667:
1.16 parser 668: // Element createElement(in DOMString tagName) raises(DOMException);
669: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
670: // DocumentFragment createDocumentFragment();
671: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
672: // Text createTextNode(in DOMString data);
673: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
674: // Comment createComment(in DOMString data);
675: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
676: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
677: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
678: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
679: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
680: // Attr createAttribute(in DOMString name) raises(DOMException);
681: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
682: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
683: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
1.2 parser 684:
1.79 paf 685: /// DOM2
1.2 parser 686:
1.16 parser 687: // ^xdoc.getElementById[elementId]
688: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.79 paf 689:
690: // Node (in Node importedNode, in boolean deep) raises(DOMException)
691: add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);
1.112 paf 692:
1.113 paf 693: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 694: add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);
695:
1.113 paf 696: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 697: add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);
1.99 paf 698:
1.16 parser 699: /// parser
700:
1.54 paf 701: // ^xdoc::create{qualifiedName}
1.95 paf 702: // ^xdoc::create[<some>xml</some>]
703: // ^xdoc::create[URI][<some>xml</some>]
704: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 2);
1.83 paf 705: // for backward compatibility with <=v 1.82 2002/01/31 11:51:46 paf
706: add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);
1.54 paf 707:
708: // ^xdoc::load[some.xml]
1.122 paf 709: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
1.54 paf 710:
1.2 parser 711: // ^xdoc.save[some.xml]
712: // ^xdoc.save[some.xml;options hash]
1.1 parser 713: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
714:
1.2 parser 715: // ^xdoc.string[] <doc/>
716: // ^xdoc.string[options hash] <doc/>
1.1 parser 717: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
718:
1.2 parser 719: // ^xdoc.file[] file with "<doc/>"
720: // ^xdoc.file[options hash] file with "<doc/>"
1.58 paf 721: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
1.1 parser 722:
1.98 paf 723: // ^xdoc.transform[stylesheet file_name/xdoc]
724: // ^xdoc.transform[stylesheet file_name/xdoc;params hash]
1.59 paf 725: add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 726:
1.5 parser 727: }
728:
1.1 parser 729: #endif
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xdoc.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / classes