Annotation of parser3/src/classes/xdoc.C, revision 1.193
1.1 parser 1: /** @file
1.2 parser 2: Parser: @b xdoc parser class.
1.1 parser 3:
1.192 moko 4: Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
1.85 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://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.193 ! moko 31: volatile const char * IDENT_XDOC_C="$Id: xdoc.C,v 1.192 2017/02/07 22:00:30 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.65 paf 121: class xsltStylesheet_auto_ptr {
122: public:
1.67 paf 123: explicit xsltStylesheet_auto_ptr(xsltStylesheet *_APtr = 0)
124: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.65 paf 125: xsltStylesheet_auto_ptr(const xsltStylesheet_auto_ptr& _Y)
126: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
127: xsltStylesheet_auto_ptr& operator=(const xsltStylesheet_auto_ptr& _Y)
128: {if (this != &_Y)
129: {if (_Ptr != _Y.get())
130: {if (_Owns && _Ptr)
131: xsltFreeStylesheet(_Ptr);
132: _Owns = _Y._Owns; }
133: else if (_Y._Owns)
134: _Owns = true;
135: _Ptr = _Y.release(); }
136: return (*this); }
137: ~xsltStylesheet_auto_ptr()
138: {if (_Owns && _Ptr)
139: xsltFreeStylesheet(_Ptr); }
140: xsltStylesheet& operator*() const
141: {return (*get()); }
142: xsltStylesheet *operator->() const
143: {return (get()); }
144: xsltStylesheet *get() const
145: {return (_Ptr); }
146: xsltStylesheet *release() const
147: {((xsltStylesheet_auto_ptr *)this)->_Owns = false;
148: return (_Ptr); }
149: private:
150: bool _Owns;
151: xsltStylesheet *_Ptr;
152: };
1.61 paf 153:
1.1 parser 154: // methods
155:
1.149 paf 156: static void writeNode(Request& r, VXdoc& xdoc, xmlNode* node) {
157: if(!node)
1.154 misha 158: throw Exception(PARSER_RUNTIME,
1.149 paf 159: 0,
160: "error creating node"); // OOM, bad name, things like that
1.54 paf 161:
162: // write out result
1.190 moko 163: r.write(xdoc.wrap(*node));
1.149 paf 164: }
165:
166: struct IdsIteratorInfo {
167: xmlChar *elementId;
168: xmlNode *element;
169: };
170:
171: /* Hash Scanner function for pa_getElementById */
172: extern "C" void // switching to calling convetion of libxml
173: idsHashScanner (void *payload, void *data, xmlChar *name) {
174: IdsIteratorInfo *priv = (IdsIteratorInfo *)data;
175:
176: if (priv->element == NULL && xmlStrEqual (name, priv->elementId))
177: {
178: xmlNode* parent=((xmlID *)payload)->attr->parent;
179: assert(parent);
180: priv->element=parent;
181: }
182: }
183:
184: static xmlNode*
185: pa_getElementById(xmlDoc& xmldoc, xmlChar* elementId) {
186: xmlHashTable *ids = (xmlHashTable *)xmldoc.ids;
187: IdsIteratorInfo iter={elementId, NULL};
188: xmlHashScan(ids, idsHashScanner, &iter);
189: return iter.element;
190: }
191:
192: /*
193: static xmlNode *
194: pa_importNode (xmlDoc& xmldoc, xmlNode& importedNode, bool deep) {
195: xmlNode *result = NULL;
196:
197: switch (importedNode.type) {
198: case XML_ATTRIBUTE_NODE:
199: result = (xmlNode *)xmlCopyProp(xmldoc, (xmlAttr *)importedNode);
200: result.parent=0; // no idea
201: break;
202: case XML_DOCUMENT_FRAG_NODE:
203: case XML_ELEMENT_NODE:
204: case XML_ENTITY_REF_NODE:
205: case XML_PI_NODE:
206: case XML_TEXT_NODE:
207: case XML_CDATA_SECTION_NODE:
208: case XML_COMMENT_NODE:
209: result = xmlCopyNode (importedNode->n, deep);
210: xmlSetTreeDoc (result, priv->n);
211: break;
212: default:
213: *exc = GDOME_NOT_SUPPORTED_ERR;
214: }
215:
216: return result;
1.54 paf 217: }
1.149 paf 218: */
1.54 paf 219:
1.16 parser 220: // Element createElement(in DOMString tagName) raises(DOMException);
1.111 paf 221: static void _createElement(Request& r, MethodParams& params) {
1.168 misha 222: xmlChar* tagName=as_xmlname(r, params, 0, "tagName must be string");
223:
1.111 paf 224: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 225: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 226:
1.149 paf 227: xmlNode *node=xmlNewDocNode(&xmldoc, NULL, tagName, NULL);
228: writeNode(r, vdoc, node);
1.16 parser 229: }
230:
1.113 paf 231: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 232: static void _createElementNS(Request& r, MethodParams& params) {
1.168 misha 233: xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
234: xmlChar* qualifiedName=as_xmlqname(r, params, 1);
235:
1.112 paf 236: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 237: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 238:
1.149 paf 239: xmlChar* prefix=0;
240: xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
1.112 paf 241:
1.149 paf 242: xmlNode *node;
243: if(localName) {
244: xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
245: node=xmlNewDocNode(&xmldoc, &ns, localName, NULL);
246: } else
247: node=xmlNewDocNode(&xmldoc, NULL, qualifiedName/*unqualified, actually*/, NULL);
248: writeNode(r, vdoc, node);
1.112 paf 249: }
250:
1.16 parser 251: // DocumentFragment createDocumentFragment()
1.111 paf 252: static void _createDocumentFragment(Request& r, MethodParams&) {
253: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 254: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 255:
1.149 paf 256: xmlNode *node=xmlNewDocFragment(&xmldoc);
257: writeNode(r, vdoc, node);
1.16 parser 258: }
259:
260: // Text createTextNode(in DOMString data);
1.111 paf 261: static void _createTextNode(Request& r, MethodParams& params) {
1.168 misha 262: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
263:
1.111 paf 264: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 265: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 266:
1.149 paf 267: xmlNode *node=xmlNewDocText(&xmldoc, data);
268: writeNode(r, vdoc, node);
1.16 parser 269: }
270:
271: // Comment createComment(in DOMString data)
1.111 paf 272: static void _createComment(Request& r, MethodParams& params) {
1.168 misha 273: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
274:
1.111 paf 275: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.16 parser 276:
1.149 paf 277: xmlNode *node=xmlNewComment(data);
278: writeNode(r, vdoc, node);
1.16 parser 279: }
280:
281: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
1.111 paf 282: static void _createCDATASection(Request& r, MethodParams& params) {
1.168 misha 283: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
284:
1.111 paf 285: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 286: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 287:
1.149 paf 288: xmlNode *node=xmlNewCDataBlock(&xmldoc, data, strlen((const char*)data));
289: writeNode(r, vdoc, node);
1.16 parser 290: }
291:
292: // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
1.111 paf 293: static void _createProcessingInstruction(Request& r, MethodParams& params) {
1.168 misha 294: xmlChar* target=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
295: xmlChar* data=as_xmlchar(r, params, 1, XML_DATA_MUST_BE_STRING);
296:
1.111 paf 297: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 298: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 299:
1.149 paf 300: xmlNode *node=xmlNewDocPI(&xmldoc, target, data);
301: writeNode(r, vdoc, node);
1.16 parser 302: }
303:
304: // Attr createAttribute(in DOMString name) raises(DOMException);
1.111 paf 305: static void _createAttribute(Request& r, MethodParams& params) {
1.168 misha 306: xmlChar* name=as_xmlname(r, params, 0);
307:
1.111 paf 308: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 309: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 310:
1.149 paf 311: xmlNode *node=(xmlNode*)xmlNewDocProp(&xmldoc, name, 0);
312: writeNode(r, vdoc, node);
1.16 parser 313: }
1.112 paf 314:
1.113 paf 315: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 316: static void _createAttributeNS(Request& r, MethodParams& params) {
1.168 misha 317: xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
318: xmlChar* qualifiedName=as_xmlqname(r, params, 1);
319:
1.112 paf 320: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 321: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 322:
1.149 paf 323: xmlChar* prefix=0;
324: xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
325:
326: xmlNode *node;
327: if(localName) {
328: xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
329: node=(xmlNode*)xmlNewDocProp(&xmldoc, localName, NULL);
330: xmlSetNs(node, &ns);
331: } else
332: node=(xmlNode*)xmlNewDocProp(&xmldoc, qualifiedName/*unqualified, actually*/, NULL);
333: writeNode(r, vdoc, node);
1.112 paf 334: }
335:
1.16 parser 336: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
1.111 paf 337: static void _createEntityReference(Request& r, MethodParams& params) {
1.168 misha 338: xmlChar* name=as_xmlname(r, params, 0);
339:
1.111 paf 340: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 341: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 342:
1.149 paf 343: xmlNode *node=xmlNewReference(&xmldoc, name);
344: writeNode(r, vdoc, node);
1.99 paf 345: }
346:
347:
1.111 paf 348: static void _getElementById(Request& r, MethodParams& params) {
1.168 misha 349: xmlChar* elementId=as_xmlname(r, params, 0, "elementID must be string");
350:
1.111 paf 351: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 352: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 353:
1.168 misha 354: if(xmlNode *node=pa_getElementById(xmldoc, elementId))
1.149 paf 355: writeNode(r, vdoc, node);
1.54 paf 356: }
1.79 paf 357:
1.111 paf 358: static void _importNode(Request& r, MethodParams& params) {
1.168 misha 359: xmlNode& importedNode=as_node(params, 0, "importedNode must be node");
360: bool deep=params.as_bool(1, "deep must be bool", r);
361:
1.111 paf 362: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 363: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.79 paf 364:
1.149 paf 365: xmlNode *node=xmlDocCopyNode(&importedNode, &xmldoc, deep?1: 0);
366: writeNode(r, vdoc, node);
1.79 paf 367: }
1.168 misha 368:
1.54 paf 369: /*
370: GdomeElement *gdome_doc_createElementNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
371: GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
372: */
1.1 parser 373:
1.111 paf 374: static void _create(Request& r, MethodParams& params) {
375: Charset& source_charset=r.charsets.source();
376: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 377:
1.111 paf 378: Value& param=params[params.count()-1];
1.149 paf 379: xmlDoc* xmldoc;
1.111 paf 380: bool set_encoding=false;
1.95 paf 381: if(param.get_junction()) { // {<?xml?>...}
1.189 moko 382:
1.91 paf 383: const String& xml=r.process_to_string(param);
1.189 moko 384: String::Body sbody=xml.cstr_to_string_body_untaint(String::L_XML, r.connection(false), &r.charsets);
1.83 paf 385:
1.163 misha 386: xmldoc=xmlParseMemory(sbody.cstr(), sbody.length());
387:
1.111 paf 388: //printf("document=0x%p\n", document);
1.149 paf 389: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 390: throw XmlException(0, r);
1.111 paf 391:
392: // must be last action in if, see after if}
1.149 paf 393: } else { // [localName]
1.153 misha 394: if(const String* value = param.get_string()){
395: xmlChar* localName=r.transcode(*value);
1.168 misha 396: if(xmlValidateNCName(localName, 0) != 0)
397: throw XmlException(0, XML_INVALID_LOCAL_NAME, localName);
398:
1.120 paf 399: #if 0
1.153 misha 400: GdomeDocumentType *documentType=gdome_di_createDocumentType (
401: docimpl,
402: r.transcode(qualifiedName),
403: 0/*publicId*/,
404: 0/*systemId*/,
405: &exc);
406: if(!documentType || exc || xmlHaveGenericErrors())
407: throw Exception(
408: method_name,
409: exc);
410: /// +xalan createXMLDecl ?
1.120 paf 411: #endif
1.151 misha 412: xmldoc=xmlNewDoc(0);
413: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 414: throw XmlException(0, r);
1.168 misha 415:
1.151 misha 416: xmlNode* node=xmlNewChild((xmlNode*)xmldoc, NULL, localName, NULL);
417: if(!node || xmlHaveGenericErrors())
1.179 moko 418: throw XmlException(0, r);
1.103 paf 419:
1.151 misha 420: set_encoding=true;
421: // must be last action in if, see after if}
1.153 misha 422: } else {
1.161 misha 423: VFile* vfile=param.as_vfile(String::L_AS_IS);
1.153 misha 424: xmldoc=xmlParseMemory(vfile->value_ptr(), vfile->value_size());
425: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 426: throw XmlException(0, r);
1.151 misha 427: }
1.111 paf 428: }
429: // must be first action after if}
430: // replace any previous parsed source
1.149 paf 431: vdoc.set_xmldoc(r.charsets, *xmldoc);
1.95 paf 432:
433: // URI
1.111 paf 434: const char* URI_cstr;
435: if(params.count()>1) { // absolute(param)
436: const String& URI=params.as_string(0, "URI must be string");
1.149 paf 437: URI_cstr=r.absolute(URI).cstr();
1.95 paf 438: } else // default = disk path to requested document
1.111 paf 439: URI_cstr=r.request_info.path_translated;
1.95 paf 440: if(URI_cstr)
1.149 paf 441: xmldoc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
1.95 paf 442:
1.111 paf 443: if(set_encoding) {
444: const char* source_charset_name=source_charset.NAME().cstr();
1.149 paf 445: xmldoc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
1.111 paf 446: }
1.9 parser 447: }
448:
1.111 paf 449: static void _load(Request& r, MethodParams& params) {
450: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.9 parser 451:
1.54 paf 452: // filespec
1.156 misha 453: const String* uri=¶ms.as_string(0, "URI must be string");
1.122 paf 454: const char* uri_cstr;
455: if(uri->pos("://")==STRING_NOT_FOUND) // disk path
1.162 misha 456: uri_cstr=r.absolute(*uri).taint_cstr(String::L_FILE_SPEC);
1.122 paf 457: else // xxx://
1.162 misha 458: uri_cstr=uri->taint_cstr(String::L_AS_IS); // leave as-is for xmlParseFile to handle
1.105 paf 459:
1.157 misha 460: /// @todo!! add SAFE MODE!!
1.149 paf 461: xmlDoc* xmldoc=xmlParseFile(uri_cstr);
462: if(!xmldoc || xmlHaveGenericErrors())
1.179 moko 463: throw XmlException(uri, r);
1.149 paf 464:
1.111 paf 465: // must be first action after if}
466: // replace any previous parsed source
1.149 paf 467: vdoc.set_xmldoc(r.charsets, *xmldoc);
1.9 parser 468: }
469:
1.166 misha 470: String::C xdoc2buf(Request& r, VXdoc& vdoc,
471: XDocOutputOptions& oo,
472: const String* file_spec,
473: bool use_source_charset_to_render_and_client_charset_to_write_to_header=false) {
1.171 misha 474: Charset* render=0;
475: Charset* header=0;
1.140 paf 476: if(use_source_charset_to_render_and_client_charset_to_write_to_header) {
1.171 misha 477: render=&r.charsets.source();
478: header=&r.charsets.client();
1.140 paf 479: } else {
1.188 moko 480: header=render=&pa_charsets.get(*oo.encoding);
1.140 paf 481: }
1.171 misha 482: const char* render_encoding=render->NAME_CSTR();
483: const char* header_encoding=header->NAME_CSTR();
1.140 paf 484:
485: xmlCharEncodingHandler *renderer=xmlFindCharEncodingHandler(render_encoding);
486: // UTF-8 renderer contains empty input/output converters,
1.61 paf 487: // which is wrong for xmlOutputBufferCreateIO
1.140 paf 488: // while zero renderer goes perfectly
1.171 misha 489: if(render->isUTF8())
1.140 paf 490: renderer=0;
1.61 paf 491:
1.140 paf 492: xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer));
1.138 paf 493:
1.65 paf 494: xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet());
495: if(!stylesheet.get())
1.87 paf 496: throw Exception(0,
1.111 paf 497: 0,
1.61 paf 498: "xsltNewStylesheet failed");
499:
1.143 paf 500: #define OOSTRING2STYLE(name) \
1.149 paf 501: stylesheet->name=oo.name?BAD_CAST xmlMemStrdup((const char*)r.transcode(*oo.name)):0
1.143 paf 502: #define OOBOOL2STYLE(name) \
503: if(oo.name>=0) stylesheet->name=oo.name
1.61 paf 504:
1.143 paf 505: OOSTRING2STYLE(method);
506: OOSTRING2STYLE(encoding);
507: OOSTRING2STYLE(mediaType);
508: // OOSTRING2STYLE(doctypeSystem);
509: // OOSTRING2STYLE(doctypePublic);
510: OOBOOL2STYLE(indent);
511: OOSTRING2STYLE(version);
512: OOBOOL2STYLE(standalone);
513: OOBOOL2STYLE(omitXmlDeclaration);
1.61 paf 514:
1.149 paf 515: xmlDoc& xmldoc=vdoc.get_xmldoc();
516: xmldoc.encoding=BAD_CAST xmlMemStrdup(render_encoding);
1.142 paf 517: if(header_encoding)
518: stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding);
1.149 paf 519: if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet.get())<0
520: || xmlHaveGenericErrors())
1.179 moko 521: throw XmlException(0, r);
1.61 paf 522:
1.138 paf 523: // write out result
1.166 misha 524: char *gnome_str;
525: size_t gnome_length;
1.180 moko 526: #ifdef LIBXML2_NEW_BUFFER
527: if(outputBuffer->conv) {
528: gnome_length=xmlBufUse(outputBuffer->conv);
529: gnome_str=(char *)xmlBufContent(outputBuffer->conv);
530: } else {
531: gnome_length=xmlOutputBufferGetSize(&(*outputBuffer));
532: gnome_str=(char *)xmlOutputBufferGetContent(&(*outputBuffer));
533: }
534: #else
1.138 paf 535: if(outputBuffer->conv) {
536: gnome_length=outputBuffer->conv->use;
537: gnome_str=(char *)outputBuffer->conv->content;
538: } else {
539: gnome_length=outputBuffer->buffer->use;
540: gnome_str=(char *)outputBuffer->buffer->content;
541: }
1.180 moko 542: #endif
1.138 paf 543:
1.166 misha 544: if(file_spec){
1.165 misha 545: file_write(r.charsets,
546: *file_spec,
547: gnome_str,
548: gnome_length,
1.111 paf 549: true/*as_text*/);
1.166 misha 550: return String::C(); // actually, we don't need this output at all
551: } else
552: return String::C(gnome_length ? pa_strdup(gnome_str, gnome_length) : 0, gnome_length);
553: }
1.111 paf 554:
1.166 misha 555: inline HashStringValue* get_options(MethodParams& params, size_t index){
556: return (params.count()>index) ? params.as_hash(index) : 0;
1.1 parser 557: }
558:
1.111 paf 559: static void _file(Request& r, MethodParams& params) {
560: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 561:
1.177 moko 562: XDocOutputOptions oo(vdoc.output_options);
563: oo.append(r, get_options(params, 0), true/* $.name[filename] could be specified by user */);
1.166 misha 564: String::C buf=xdoc2buf(r, vdoc, oo, 0/*file_name. not to file, to memory*/);
565:
1.111 paf 566: VFile& vfile=*new VFile;
567: VHash& vhcontent_type=*new VHash;
1.182 moko 568: vhcontent_type.hash().put(value_name, new VString(*oo.mediaType));
569: vhcontent_type.hash().put("charset", new VString(*oo.encoding));
1.111 paf 570:
1.176 moko 571: 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 572:
1.166 misha 573: // write out result
1.190 moko 574: r.write(vfile);
1.63 paf 575: }
576:
1.111 paf 577: static void _save(Request& r, MethodParams& params) {
578: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.63 paf 579:
1.155 misha 580: const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));
1.63 paf 581:
1.177 moko 582: XDocOutputOptions oo(vdoc.output_options);
583: oo.append(r, get_options(params, 1));
1.166 misha 584: xdoc2buf(r, vdoc, oo, &file_spec);
1.63 paf 585: }
586:
1.111 paf 587: static void _string(Request& r, MethodParams& params) {
588: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.166 misha 589:
1.177 moko 590: XDocOutputOptions oo(vdoc.output_options);
591: oo.append(r, get_options(params, 0));
1.166 misha 592: String::C buf=xdoc2buf(r, vdoc, oo,
593: 0/*file_name. not to file, to memory*/,
1.140 paf 594: true/*use source charset to render, client charset to put to header*/);
1.166 misha 595:
1.63 paf 596: // write out result
1.190 moko 597: r.write(String(buf, String::L_AS_IS));
1.1 parser 598: }
1.58 paf 599:
1.111 paf 600: #ifndef DOXYGEN
601: struct Add_xslt_param_info {
602: Request* r;
1.149 paf 603: Array<const xmlChar*>* strings;
604: const xmlChar** current_transform_param;
1.111 paf 605: };
606: #endif
607: static void add_xslt_param(
608: HashStringValue::key_type attribute,
609: HashStringValue::value_type meaning,
610: Add_xslt_param_info* info) {
1.149 paf 611: xmlChar* s;
612: *info->current_transform_param++=(s=info->r->transcode(attribute)); *info->strings+=s;
613: *info->current_transform_param++=(s=info->r->transcode(meaning->as_string())); *info->strings+=s;
1.111 paf 614: }
1.132 paf 615:
1.111 paf 616: static VXdoc& _transform(Request& r, const String* stylesheet_source,
1.149 paf 617: VXdoc& vdoc, xsltStylesheetPtr stylesheet, const xmlChar** transform_params)
1.132 paf 618: {
1.149 paf 619: xmlDoc& xmldoc=vdoc.get_xmldoc();
620:
1.65 paf 621: xsltTransformContext_auto_ptr transformContext(
1.149 paf 622: xsltNewTransformContext(stylesheet, &xmldoc));
1.90 paf 623: // make params literal
1.111 paf 624: if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
1.90 paf 625: transformContext->globalVars = xmlHashCreate(20);
1.149 paf 626: xsltQuoteUserParams(transformContext.get(), (const char**)transform_params);
1.90 paf 627: // do transform
1.59 paf 628: xmlDoc *transformed=xsltApplyStylesheetUser(
629: stylesheet,
1.149 paf 630: &xmldoc,
1.90 paf 631: 0/*already quoted-inserted transform_params*/,
1.111 paf 632: 0/*const char* output*/,
1.59 paf 633: 0/*FILE *profile*/,
1.65 paf 634: transformContext.get());
1.149 paf 635: if(!transformed || xmlHaveGenericErrors())
1.179 moko 636: throw XmlException(stylesheet_source, r);
1.42 paf 637:
1.61 paf 638: //gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing
639: transformed->type=XML_DOCUMENT_NODE;
1.177 moko 640: // constructing result
641: VXdoc& result=*new VXdoc(r.charsets, *transformed);
642: /* grabbing options
643:
644: <xsl:output
645: !method = "xml" | "html" | "text"
646: X| qname-but-not-ncname
647: !version = nmtoken
648: !encoding = string
649: !omit-xml-declaration = "yes" | "no"
650: !standalone = "yes" | "no"
651: !doctype-public = string
652: !doctype-system = string
653: Xcdata-section-elements = qnames
654: !indent = "yes" | "no"
655: !media-type = string />
656: */
657: XDocOutputOptions& oo=result.output_options;
658:
659: oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
660: oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
661: oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
662: oo.indent=stylesheet->indent;
663: oo.version=stylesheet->version?&r.transcode(stylesheet->version):0;
664: oo.standalone=stylesheet->standalone;
665: oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration;
1.167 misha 666:
1.177 moko 667: // return
668: return result;
1.93 paf 669: }
1.111 paf 670: static void _transform(Request& r, MethodParams& params) {
671: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.93 paf 672:
673: // params
1.149 paf 674: Array<const xmlChar*> transform_strings;
675: const xmlChar** transform_params=0;
1.166 misha 676: if(params.count()>1)
1.174 misha 677: if(HashStringValue* hash=params.as_hash(1, "transform options")) {
1.193 ! moko 678: transform_params=new(PointerGC) const xmlChar*[hash->count()*2+1];
1.166 misha 679: Add_xslt_param_info info={
680: &r,
681: &transform_strings,
682: transform_params
683: };
684: hash->for_each<Add_xslt_param_info*>(add_xslt_param, &info);
685: transform_params[hash->count()*2]=0;
686: }
1.93 paf 687:
1.111 paf 688: VXdoc* result;
1.164 misha 689: if(Value *vxdoc=params[0].as(VXDOC_TYPE)) { // stylesheet (xdoc)
1.191 moko 690: VXdoc& vstylesheet=static_cast<VXdoc &>(*vxdoc);
691:
692: if(!vstylesheet.stylesheet){
693: xmlDoc& stylesheetdoc=vstylesheet.get_xmldoc();
694:
695: // compile xdoc stylesheet
696: vstylesheet.stylesheet=xsltParseStylesheetDoc(&stylesheetdoc);
697: if(xmlHaveGenericErrors())
698: throw XmlException(0, r);
699: if(!vstylesheet.stylesheet)
700: throw Exception("xml", 0, "stylesheet failed to compile");
701: }
1.93 paf 702:
703: // transform!
1.191 moko 704: result=&_transform(r, 0, vdoc, vstylesheet.stylesheet, transform_params);
1.93 paf 705: } else { // stylesheet (file name)
706: // extablish stylesheet connection
707: const String& stylesheet_filespec=
1.111 paf 708: r.absolute(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
1.125 paf 709: Stylesheet_connection_ptr connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.93 paf 710:
711: // load and compile file to stylesheet [or get cached if any]
712: // transform!
1.191 moko 713: result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(), transform_params);
1.93 paf 714: }
715:
1.59 paf 716: // write out result
1.190 moko 717: r.write(*result);
1.1 parser 718: }
719:
1.16 parser 720: // constructor
1.2 parser 721:
1.92 paf 722: /// @test how to create empty type html?
1.185 moko 723: MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME) {
724: set_base(xnode_class);
725:
1.16 parser 726: /// DOM1
1.2 parser 727:
1.16 parser 728: // Element createElement(in DOMString tagName) raises(DOMException);
729: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
730: // DocumentFragment createDocumentFragment();
731: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
732: // Text createTextNode(in DOMString data);
733: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
734: // Comment createComment(in DOMString data);
735: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
736: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
737: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
738: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
739: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
740: // Attr createAttribute(in DOMString name) raises(DOMException);
741: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
742: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
743: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
1.2 parser 744:
1.79 paf 745: /// DOM2
1.2 parser 746:
1.16 parser 747: // ^xdoc.getElementById[elementId]
748: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.79 paf 749:
750: // Node (in Node importedNode, in boolean deep) raises(DOMException)
751: add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);
1.112 paf 752:
1.113 paf 753: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 754: add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);
755:
1.113 paf 756: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 757: add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);
1.99 paf 758:
1.16 parser 759: /// parser
760:
1.54 paf 761: // ^xdoc::create{qualifiedName}
1.95 paf 762: // ^xdoc::create[<some>xml</some>]
763: // ^xdoc::create[URI][<some>xml</some>]
764: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 2);
1.83 paf 765: // for backward compatibility with <=v 1.82 2002/01/31 11:51:46 paf
766: add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);
1.54 paf 767:
768: // ^xdoc::load[some.xml]
1.122 paf 769: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
1.54 paf 770:
1.2 parser 771: // ^xdoc.save[some.xml]
772: // ^xdoc.save[some.xml;options hash]
1.1 parser 773: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
774:
1.2 parser 775: // ^xdoc.string[] <doc/>
776: // ^xdoc.string[options hash] <doc/>
1.1 parser 777: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
778:
1.2 parser 779: // ^xdoc.file[] file with "<doc/>"
780: // ^xdoc.file[options hash] file with "<doc/>"
1.58 paf 781: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
1.1 parser 782:
1.98 paf 783: // ^xdoc.transform[stylesheet file_name/xdoc]
784: // ^xdoc.transform[stylesheet file_name/xdoc;params hash]
1.59 paf 785: add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 786:
1.5 parser 787: }
788:
1.111 paf 789: # else
790:
791: #include "classes.h"
792:
1.1 parser 793: // global variable
794:
1.186 moko 795: DECLARE_CLASS_VAR(xnode, 0); // fictive
1.184 moko 796: DECLARE_CLASS_VAR(xdoc, 0); // fictive
1.1 parser 797:
798: #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