Annotation of parser3/src/classes/xdoc.C, revision 1.166
1.1 parser 1: /** @file
1.2 parser 2: Parser: @b xdoc parser class.
1.1 parser 3:
1.157 misha 4: Copyright (c) 2001-2009 ArtLebedev Group (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.166 ! misha 12: static const char * const IDENT_XDOC_C="$Date: 2009-09-08 09:11:51 $";
1.82 paf 13:
1.69 paf 14: #include "libxml/tree.h"
1.133 paf 15: #include "libxml/HTMLtree.h"
1.69 paf 16: #include "libxslt/xsltInternals.h"
17: #include "libxslt/transform.h"
18: #include "libxslt/xsltutils.h"
1.90 paf 19: #include "libxslt/variables.h"
1.132 paf 20: #include "libxslt/imports.h"
1.111 paf 21:
22: #include "pa_vmethod_frame.h"
23:
24: #include "pa_stylesheet_manager.h"
25: #include "pa_request.h"
26: #include "pa_vxdoc.h"
27: #include "pa_charset.h"
28: #include "pa_vfile.h"
1.115 paf 29: #include "pa_xml_exception.h"
1.111 paf 30: #include "xnode.h"
31:
1.1 parser 32: // defines
33:
34: #define XDOC_CLASS_NAME "xdoc"
35:
36: // class
37:
1.111 paf 38: class MXdoc: public MXnode {
1.1 parser 39: public: // VStateless_class
1.164 misha 40: Value* create_new_value(Pool&) { return new VXdoc(); }
1.1 parser 41:
42: public:
1.111 paf 43: MXdoc();
1.1 parser 44:
45: };
46:
1.111 paf 47: // global variable
48:
49: DECLARE_CLASS_VAR(xdoc, new MXdoc, 0);
1.61 paf 50:
1.138 paf 51: // helper classes
52:
53: class xmlOutputBuffer_auto_ptr {
54: public:
55: explicit xmlOutputBuffer_auto_ptr(xmlOutputBuffer *_APtr = 0)
56: : _Owns(_APtr != 0), _Ptr(_APtr) {}
57: xmlOutputBuffer_auto_ptr(const xmlOutputBuffer_auto_ptr& _Y)
58: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
59: xmlOutputBuffer_auto_ptr& operator=(const xmlOutputBuffer_auto_ptr& _Y)
60: {if (this != &_Y)
61: {if (_Ptr != _Y.get())
62: {if (_Owns && _Ptr)
63: xmlOutputBufferClose(_Ptr);
64: _Owns = _Y._Owns; }
65: else if (_Y._Owns)
66: _Owns = true;
67: _Ptr = _Y.release(); }
68: return (*this); }
69: ~xmlOutputBuffer_auto_ptr()
70: {if (_Owns && _Ptr)
71: xmlOutputBufferClose(_Ptr); }
72: xmlOutputBuffer& operator*() const
73: {return (*get()); }
74: xmlOutputBuffer *operator->() const
75: {return (get()); }
76: xmlOutputBuffer *get() const
77: {return (_Ptr); }
78: xmlOutputBuffer *release() const
79: {((xmlOutputBuffer_auto_ptr *)this)->_Owns = false;
80: return (_Ptr); }
81: private:
82: bool _Owns;
83: xmlOutputBuffer *_Ptr;
84: };
85:
1.65 paf 86: class xsltTransformContext_auto_ptr {
87: public:
1.67 paf 88: explicit xsltTransformContext_auto_ptr(xsltTransformContext *_APtr = 0)
89: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.65 paf 90: xsltTransformContext_auto_ptr(const xsltTransformContext_auto_ptr& _Y)
91: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
92: xsltTransformContext_auto_ptr& operator=(const xsltTransformContext_auto_ptr& _Y)
93: {if (this != &_Y)
94: {if (_Ptr != _Y.get())
95: {if (_Owns && _Ptr)
96: xsltFreeTransformContext(_Ptr);
97: _Owns = _Y._Owns; }
98: else if (_Y._Owns)
99: _Owns = true;
100: _Ptr = _Y.release(); }
101: return (*this); }
102: ~xsltTransformContext_auto_ptr()
103: {if (_Owns && _Ptr)
104: xsltFreeTransformContext(_Ptr); }
105: xsltTransformContext& operator*() const
106: {return (*get()); }
107: xsltTransformContext *operator->() const
108: {return (get()); }
109: xsltTransformContext *get() const
110: {return (_Ptr); }
111: xsltTransformContext *release() const
112: {((xsltTransformContext_auto_ptr *)this)->_Owns = false;
113: return (_Ptr); }
114: private:
115: bool _Owns;
116: xsltTransformContext *_Ptr;
117: };
1.61 paf 118:
1.65 paf 119: class xsltStylesheet_auto_ptr {
120: public:
1.67 paf 121: explicit xsltStylesheet_auto_ptr(xsltStylesheet *_APtr = 0)
122: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.65 paf 123: xsltStylesheet_auto_ptr(const xsltStylesheet_auto_ptr& _Y)
124: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
125: xsltStylesheet_auto_ptr& operator=(const xsltStylesheet_auto_ptr& _Y)
126: {if (this != &_Y)
127: {if (_Ptr != _Y.get())
128: {if (_Owns && _Ptr)
129: xsltFreeStylesheet(_Ptr);
130: _Owns = _Y._Owns; }
131: else if (_Y._Owns)
132: _Owns = true;
133: _Ptr = _Y.release(); }
134: return (*this); }
135: ~xsltStylesheet_auto_ptr()
136: {if (_Owns && _Ptr)
137: xsltFreeStylesheet(_Ptr); }
138: xsltStylesheet& operator*() const
139: {return (*get()); }
140: xsltStylesheet *operator->() const
141: {return (get()); }
142: xsltStylesheet *get() const
143: {return (_Ptr); }
144: xsltStylesheet *release() const
145: {((xsltStylesheet_auto_ptr *)this)->_Owns = false;
146: return (_Ptr); }
147: private:
148: bool _Owns;
149: xsltStylesheet *_Ptr;
150: };
1.61 paf 151:
1.1 parser 152: // methods
153:
1.149 paf 154: static void writeNode(Request& r, VXdoc& xdoc, xmlNode* node) {
155: if(!node)
1.154 misha 156: throw Exception(PARSER_RUNTIME,
1.149 paf 157: 0,
158: "error creating node"); // OOM, bad name, things like that
1.54 paf 159:
160: // write out result
1.149 paf 161: r.write_no_lang(xdoc.wrap(*node));
162: }
163:
164: struct IdsIteratorInfo {
165: xmlChar *elementId;
166: xmlNode *element;
167: };
168:
169: /* Hash Scanner function for pa_getElementById */
170: extern "C" void // switching to calling convetion of libxml
171: idsHashScanner (void *payload, void *data, xmlChar *name) {
172: IdsIteratorInfo *priv = (IdsIteratorInfo *)data;
173:
174: if (priv->element == NULL && xmlStrEqual (name, priv->elementId))
175: {
176: xmlNode* parent=((xmlID *)payload)->attr->parent;
177: assert(parent);
178: priv->element=parent;
179: }
180: }
181:
182: static xmlNode*
183: pa_getElementById(xmlDoc& xmldoc, xmlChar* elementId) {
184: xmlHashTable *ids = (xmlHashTable *)xmldoc.ids;
185: IdsIteratorInfo iter={elementId, NULL};
186: xmlHashScan(ids, idsHashScanner, &iter);
187: return iter.element;
188: }
189:
190: /*
191: static xmlNode *
192: pa_importNode (xmlDoc& xmldoc, xmlNode& importedNode, bool deep) {
193: xmlNode *result = NULL;
194:
195: switch (importedNode.type) {
196: case XML_ATTRIBUTE_NODE:
197: result = (xmlNode *)xmlCopyProp(xmldoc, (xmlAttr *)importedNode);
198: result.parent=0; // no idea
199: break;
200: case XML_DOCUMENT_FRAG_NODE:
201: case XML_ELEMENT_NODE:
202: case XML_ENTITY_REF_NODE:
203: case XML_PI_NODE:
204: case XML_TEXT_NODE:
205: case XML_CDATA_SECTION_NODE:
206: case XML_COMMENT_NODE:
207: result = xmlCopyNode (importedNode->n, deep);
208: xmlSetTreeDoc (result, priv->n);
209: break;
210: default:
211: *exc = GDOME_NOT_SUPPORTED_ERR;
212: }
213:
214: return result;
1.54 paf 215: }
1.149 paf 216: */
1.54 paf 217:
1.16 parser 218: // Element createElement(in DOMString tagName) raises(DOMException);
1.111 paf 219: static void _createElement(Request& r, MethodParams& params) {
220: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 221: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 222:
1.149 paf 223: xmlChar* tagName=as_xmlchar(r, params, 0, "tagName must be string");
1.16 parser 224:
1.149 paf 225: xmlNode *node=xmlNewDocNode(&xmldoc, NULL, tagName, NULL);
226: writeNode(r, vdoc, node);
1.16 parser 227: }
228:
1.113 paf 229: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 230: static void _createElementNS(Request& r, MethodParams& params) {
231: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 232: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 233:
234: // namespaceURI;localName
1.155 misha 235: xmlChar* namespaceURI=as_xmlchar(r, params, 0, NAMESPACEURI_MUST_BE_STRING);
1.149 paf 236: xmlChar* qualifiedName=as_xmlchar(r, params, 1, "qualifiedName must be string");
237:
238: xmlChar* prefix=0;
239: xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
1.112 paf 240:
1.149 paf 241: xmlNode *node;
242: if(localName) {
243: xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
244: node=xmlNewDocNode(&xmldoc, &ns, localName, NULL);
245: } else
246: node=xmlNewDocNode(&xmldoc, NULL, qualifiedName/*unqualified, actually*/, NULL);
247: writeNode(r, vdoc, node);
1.112 paf 248: }
249:
1.16 parser 250: // DocumentFragment createDocumentFragment()
1.111 paf 251: static void _createDocumentFragment(Request& r, MethodParams&) {
252: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 253: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 254:
1.149 paf 255: xmlNode *node=xmlNewDocFragment(&xmldoc);
256: writeNode(r, vdoc, node);
1.16 parser 257: }
258:
259: // Text createTextNode(in DOMString data);
1.111 paf 260: static void _createTextNode(Request& r, MethodParams& params) {
261: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 262: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 263:
1.156 misha 264: xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
1.16 parser 265:
1.149 paf 266: xmlNode *node=xmlNewDocText(&xmldoc, data);
267: writeNode(r, vdoc, node);
1.16 parser 268: }
269:
270: // Comment createComment(in DOMString data)
1.111 paf 271: static void _createComment(Request& r, MethodParams& params) {
272: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.16 parser 273:
1.156 misha 274: xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
1.16 parser 275:
1.149 paf 276: xmlNode *node=xmlNewComment(data);
277: writeNode(r, vdoc, node);
1.16 parser 278: }
279:
280: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
1.111 paf 281: static void _createCDATASection(Request& r, MethodParams& params) {
282: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 283: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 284:
1.156 misha 285: xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
1.16 parser 286:
1.149 paf 287: xmlNode *node=xmlNewCDataBlock(&xmldoc, data, strlen((const char*)data));
288: writeNode(r, vdoc, node);
1.16 parser 289: }
290:
291: // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
1.111 paf 292: static void _createProcessingInstruction(Request& r, MethodParams& params) {
293: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 294: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 295:
1.156 misha 296: xmlChar* target=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
297: xmlChar* data=as_xmlchar(r, params, 1, DATA_MUST_BE_STRING);
1.16 parser 298:
1.149 paf 299: xmlNode *node=xmlNewDocPI(&xmldoc, target, data);
300: writeNode(r, vdoc, node);
1.16 parser 301: }
302:
303: // Attr createAttribute(in DOMString name) raises(DOMException);
1.111 paf 304: static void _createAttribute(Request& r, MethodParams& params) {
305: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 306: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 307:
1.155 misha 308: xmlChar* name=as_xmlchar(r, params, 0, NAME_MUST_BE_STRING);
1.16 parser 309:
1.149 paf 310: xmlNode *node=(xmlNode*)xmlNewDocProp(&xmldoc, name, 0);
311: writeNode(r, vdoc, node);
1.16 parser 312: }
1.112 paf 313:
1.113 paf 314: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 315: static void _createAttributeNS(Request& r, MethodParams& params) {
316: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 317: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 318:
1.155 misha 319: xmlChar* namespaceURI=as_xmlchar(r, params, 0, NAMESPACEURI_MUST_BE_STRING);
320: xmlChar* qualifiedName=as_xmlchar(r, params, 1, NAME_MUST_BE_STRING);
1.149 paf 321:
322: xmlChar* prefix=0;
323: xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
324:
325: xmlNode *node;
326: if(localName) {
327: xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
328: node=(xmlNode*)xmlNewDocProp(&xmldoc, localName, NULL);
329: xmlSetNs(node, &ns);
330: } else
331: node=(xmlNode*)xmlNewDocProp(&xmldoc, qualifiedName/*unqualified, actually*/, NULL);
332: writeNode(r, vdoc, node);
1.112 paf 333: }
334:
1.16 parser 335: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
1.111 paf 336: static void _createEntityReference(Request& r, MethodParams& params) {
337: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 338: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 339:
1.155 misha 340: xmlChar* name=as_xmlchar(r, params, 0, NAME_MUST_BE_STRING);
1.16 parser 341:
1.149 paf 342: xmlNode *node=xmlNewReference(&xmldoc, name);
343: writeNode(r, vdoc, node);
1.99 paf 344: }
345:
346:
1.111 paf 347: static void _getElementById(Request& r, MethodParams& params) {
348: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 349: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 350:
1.54 paf 351: // elementId
1.149 paf 352: xmlChar* elementId=as_xmlchar(r, params, 0, "elementID must be string");
1.1 parser 353:
1.149 paf 354: if(xmlNode *node=pa_getElementById(xmldoc, elementId)) {
1.54 paf 355: // write out result
1.149 paf 356: writeNode(r, vdoc, node);
357: }
1.54 paf 358: }
1.79 paf 359:
1.111 paf 360: static void _importNode(Request& r, MethodParams& params) {
361: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 362: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.79 paf 363:
1.149 paf 364: xmlNode& importedNode=
1.111 paf 365: as_node(params, 0, "importedNode must be node");
1.79 paf 366: bool deep=
1.111 paf 367: params.as_bool(1, "deep must be bool", r);
1.79 paf 368:
1.149 paf 369: xmlNode *node=xmlDocCopyNode(&importedNode, &xmldoc, deep?1: 0);
1.79 paf 370: // write out result
1.149 paf 371: writeNode(r, vdoc, node);
1.79 paf 372: }
1.54 paf 373: /*
374: GdomeElement *gdome_doc_createElementNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
375: GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
376: */
1.1 parser 377:
1.111 paf 378: static void _create(Request& r, MethodParams& params) {
379: Charset& source_charset=r.charsets.source();
380: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 381:
1.111 paf 382: Value& param=params[params.count()-1];
1.149 paf 383: xmlDoc* xmldoc;
1.111 paf 384: bool set_encoding=false;
1.95 paf 385: if(param.get_junction()) { // {<?xml?>...}
1.111 paf 386: Temp_lang temp_lang(r, String::L_XML);
1.91 paf 387: const String& xml=r.process_to_string(param);
1.83 paf 388:
1.163 misha 389: String::Body sbody=xml.cstr_to_string_body_untaint(r.flang, 0, &r.charsets);
390: xmldoc=xmlParseMemory(sbody.cstr(), sbody.length());
391:
1.111 paf 392: //printf("document=0x%p\n", document);
1.149 paf 393: if(!xmldoc || xmlHaveGenericErrors())
394: throw XmlException(0);
1.111 paf 395:
396: // must be last action in if, see after if}
1.149 paf 397: } else { // [localName]
1.153 misha 398: if(const String* value = param.get_string()){
399: xmlChar* localName=r.transcode(*value);
1.120 paf 400: #if 0
1.153 misha 401: GdomeDocumentType *documentType=gdome_di_createDocumentType (
402: docimpl,
403: r.transcode(qualifiedName),
404: 0/*publicId*/,
405: 0/*systemId*/,
406: &exc);
407: if(!documentType || exc || xmlHaveGenericErrors())
408: throw Exception(
409: method_name,
410: exc);
411: /// +xalan createXMLDecl ?
1.120 paf 412: #endif
1.151 misha 413: xmldoc=xmlNewDoc(0);
414: if(!xmldoc || xmlHaveGenericErrors())
415: throw XmlException(0);
416: xmlNode* node=xmlNewChild((xmlNode*)xmldoc, NULL, localName, NULL);
417: if(!node || xmlHaveGenericErrors())
418: throw XmlException(0);
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())
426: throw XmlException(0);
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())
463: throw XmlException(uri);
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.140 paf 474: const char* render_encoding;
475: const char* header_encoding;
476: if(use_source_charset_to_render_and_client_charset_to_write_to_header) {
477: render_encoding=r.charsets.source().NAME_CSTR();
478: header_encoding=r.charsets.client().NAME_CSTR();
479: } else {
480: header_encoding=render_encoding=oo.encoding->cstr();
481: }
482:
483: xmlCharEncodingHandler *renderer=xmlFindCharEncodingHandler(render_encoding);
484: if(!renderer)
1.154 misha 485: throw Exception(PARSER_RUNTIME,
1.111 paf 486: 0,
1.140 paf 487: "encoding '%s' not supported", render_encoding);
488: // UTF-8 renderer contains empty input/output converters,
1.61 paf 489: // which is wrong for xmlOutputBufferCreateIO
1.140 paf 490: // while zero renderer goes perfectly
491: if(strcmp(render_encoding, "UTF-8")==0)
492: renderer=0;
1.61 paf 493:
1.140 paf 494: xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer));
1.138 paf 495:
1.65 paf 496: xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet());
497: if(!stylesheet.get())
1.87 paf 498: throw Exception(0,
1.111 paf 499: 0,
1.61 paf 500: "xsltNewStylesheet failed");
501:
1.143 paf 502: #define OOSTRING2STYLE(name) \
1.149 paf 503: stylesheet->name=oo.name?BAD_CAST xmlMemStrdup((const char*)r.transcode(*oo.name)):0
1.143 paf 504: #define OOBOOL2STYLE(name) \
505: if(oo.name>=0) stylesheet->name=oo.name
1.61 paf 506:
1.143 paf 507: OOSTRING2STYLE(method);
508: OOSTRING2STYLE(encoding);
509: OOSTRING2STYLE(mediaType);
510: // OOSTRING2STYLE(doctypeSystem);
511: // OOSTRING2STYLE(doctypePublic);
512: OOBOOL2STYLE(indent);
513: OOSTRING2STYLE(version);
514: OOBOOL2STYLE(standalone);
515: OOBOOL2STYLE(omitXmlDeclaration);
1.61 paf 516:
1.149 paf 517: xmlDoc& xmldoc=vdoc.get_xmldoc();
518: xmldoc.encoding=BAD_CAST xmlMemStrdup(render_encoding);
1.142 paf 519: if(header_encoding)
520: stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding);
1.149 paf 521: if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet.get())<0
522: || xmlHaveGenericErrors())
523: throw XmlException(0);
1.61 paf 524:
1.138 paf 525: // write out result
1.166 ! misha 526: char *gnome_str;
! 527: size_t gnome_length;
1.138 paf 528: if(outputBuffer->conv) {
529: gnome_length=outputBuffer->conv->use;
530: gnome_str=(char *)outputBuffer->conv->content;
531: } else {
532: gnome_length=outputBuffer->buffer->use;
533: gnome_str=(char *)outputBuffer->buffer->content;
534: }
535:
1.166 ! misha 536: if(file_spec){
1.165 misha 537: file_write(r.charsets,
538: *file_spec,
539: gnome_str,
540: gnome_length,
1.111 paf 541: true/*as_text*/);
1.166 ! misha 542: return String::C(); // actually, we don't need this output at all
! 543: } else
! 544: return String::C(gnome_length ? pa_strdup(gnome_str, gnome_length) : 0, gnome_length);
! 545: }
1.111 paf 546:
1.166 ! misha 547: inline HashStringValue* get_options(MethodParams& params, size_t index){
! 548: return (params.count()>index) ? params.as_hash(index) : 0;
1.1 parser 549: }
550:
1.111 paf 551: static void _file(Request& r, MethodParams& params) {
552: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 553:
1.166 ! misha 554: XDocOutputOptions oo(r, get_options(params, 0));
! 555: String::C buf=xdoc2buf(r, vdoc, oo, 0/*file_name. not to file, to memory*/);
! 556:
1.111 paf 557: VFile& vfile=*new VFile;
558: VHash& vhcontent_type=*new VHash;
559: vhcontent_type.hash().put(
560: value_name,
561: new VString(*oo.mediaType));
562: vhcontent_type.hash().put(
1.126 paf 563: String::Body("charset"),
1.111 paf 564: new VString(*oo.encoding));
565:
566: vfile.set(false/*tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length,
567: 0/*file_name*/, &vhcontent_type);
1.166 ! misha 568:
! 569: // write out result
1.58 paf 570: r.write_no_lang(vfile);
1.63 paf 571: }
572:
1.111 paf 573: static void _save(Request& r, MethodParams& params) {
574: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.63 paf 575:
1.155 misha 576: const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));
1.63 paf 577:
1.166 ! misha 578: XDocOutputOptions oo(r, get_options(params, 1));
! 579: xdoc2buf(r, vdoc, oo, &file_spec);
1.63 paf 580: }
581:
1.111 paf 582: static void _string(Request& r, MethodParams& params) {
583: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.166 ! misha 584:
! 585: XDocOutputOptions oo(r, get_options(params, 0));
! 586: String::C buf=xdoc2buf(r, vdoc, oo,
! 587: 0/*file_name. not to file, to memory*/,
1.140 paf 588: true/*use source charset to render, client charset to put to header*/);
1.166 ! misha 589:
1.63 paf 590: // write out result
1.166 ! misha 591: r.write_no_lang(String(buf, String::L_AS_IS));
1.1 parser 592: }
1.58 paf 593:
1.111 paf 594: #ifndef DOXYGEN
595: struct Add_xslt_param_info {
596: Request* r;
1.149 paf 597: Array<const xmlChar*>* strings;
598: const xmlChar** current_transform_param;
1.111 paf 599: };
600: #endif
601: static void add_xslt_param(
602: HashStringValue::key_type attribute,
603: HashStringValue::value_type meaning,
604: Add_xslt_param_info* info) {
1.149 paf 605: xmlChar* s;
606: *info->current_transform_param++=(s=info->r->transcode(attribute)); *info->strings+=s;
607: *info->current_transform_param++=(s=info->r->transcode(meaning->as_string())); *info->strings+=s;
1.111 paf 608: }
1.132 paf 609:
1.111 paf 610: static VXdoc& _transform(Request& r, const String* stylesheet_source,
1.149 paf 611: VXdoc& vdoc, xsltStylesheetPtr stylesheet, const xmlChar** transform_params)
1.132 paf 612: {
1.149 paf 613: xmlDoc& xmldoc=vdoc.get_xmldoc();
614:
1.65 paf 615: xsltTransformContext_auto_ptr transformContext(
1.149 paf 616: xsltNewTransformContext(stylesheet, &xmldoc));
1.90 paf 617: // make params literal
1.111 paf 618: if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
1.90 paf 619: transformContext->globalVars = xmlHashCreate(20);
1.149 paf 620: xsltQuoteUserParams(transformContext.get(), (const char**)transform_params);
1.90 paf 621: // do transform
1.59 paf 622: xmlDoc *transformed=xsltApplyStylesheetUser(
623: stylesheet,
1.149 paf 624: &xmldoc,
1.90 paf 625: 0/*already quoted-inserted transform_params*/,
1.111 paf 626: 0/*const char* output*/,
1.59 paf 627: 0/*FILE *profile*/,
1.65 paf 628: transformContext.get());
1.149 paf 629: if(!transformed || xmlHaveGenericErrors())
630: throw XmlException(stylesheet_source);
1.42 paf 631:
1.61 paf 632: //gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing
633: transformed->type=XML_DOCUMENT_NODE;
1.59 paf 634: // constructing result
1.149 paf 635: VXdoc& result=*new VXdoc(r.charsets, *transformed);
1.61 paf 636: /* grabbing options
637:
638: <xsl:output
639: !method = "xml" | "html" | "text"
640: X| qname-but-not-ncname
641: !version = nmtoken
642: !encoding = string
643: !omit-xml-declaration = "yes" | "no"
644: !standalone = "yes" | "no"
645: !doctype-public = string
646: !doctype-system = string
647: Xcdata-section-elements = qnames
648: !indent = "yes" | "no"
649: !media-type = string />
1.59 paf 650: */
1.166 ! misha 651: XDocOutputOptions& oo=result.output_options;
1.59 paf 652:
1.111 paf 653: oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
654: oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
655: oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
1.143 paf 656: oo.indent=stylesheet->indent;
1.111 paf 657: oo.version=stylesheet->version?&r.transcode(stylesheet->version):0;
1.143 paf 658: oo.standalone=stylesheet->standalone;
659: oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration;
1.59 paf 660:
1.93 paf 661: // return
662: return result;
663: }
1.111 paf 664: static void _transform(Request& r, MethodParams& params) {
665: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.93 paf 666:
667: // params
1.149 paf 668: Array<const xmlChar*> transform_strings;
669: const xmlChar** transform_params=0;
1.166 ! misha 670: if(params.count()>1)
! 671: if(HashStringValue* hash=params.as_hash(1)) {
! 672: transform_params=new(UseGC) const xmlChar*[hash->count()*2+1];
! 673: Add_xslt_param_info info={
! 674: &r,
! 675: &transform_strings,
! 676: transform_params
! 677: };
! 678: hash->for_each<Add_xslt_param_info*>(add_xslt_param, &info);
! 679: transform_params[hash->count()*2]=0;
! 680: }
1.93 paf 681:
1.111 paf 682: VXdoc* result;
1.164 misha 683: if(Value *vxdoc=params[0].as(VXDOC_TYPE)) { // stylesheet (xdoc)
1.149 paf 684: xmlDoc& stylesheetdoc=static_cast<VXdoc *>(vxdoc)->get_xmldoc();
1.93 paf 685: // compile xdoc stylesheet
1.149 paf 686: xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(&stylesheetdoc));
687: if(xmlHaveGenericErrors())
688: throw XmlException(0);
1.93 paf 689: if(!stylesheet_ptr.get())
690: throw Exception("xml",
1.111 paf 691: 0,
1.93 paf 692: "stylesheet failed to compile");
1.128 paf 693: // strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
694: // we don't need that
695: stylesheet_ptr->doc=0;
1.93 paf 696:
697: // transform!
1.111 paf 698: result=&_transform(r, 0,
1.93 paf 699: vdoc, stylesheet_ptr.get(),
700: transform_params);
701: } else { // stylesheet (file name)
702: // extablish stylesheet connection
703: const String& stylesheet_filespec=
1.111 paf 704: r.absolute(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
1.125 paf 705: Stylesheet_connection_ptr connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.93 paf 706:
707: // load and compile file to stylesheet [or get cached if any]
708: // transform!
1.122 paf 709: result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(),
1.93 paf 710: transform_params);
711: }
712:
1.59 paf 713: // write out result
1.93 paf 714: r.write_no_lang(*result);
1.1 parser 715: }
716:
1.16 parser 717: // constructor
1.2 parser 718:
1.92 paf 719: /// @test how to create empty type html?
1.111 paf 720: MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, xnode_class) {
1.16 parser 721: /// DOM1
1.2 parser 722:
1.16 parser 723: // Element createElement(in DOMString tagName) raises(DOMException);
724: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
725: // DocumentFragment createDocumentFragment();
726: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
727: // Text createTextNode(in DOMString data);
728: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
729: // Comment createComment(in DOMString data);
730: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
731: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
732: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
733: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
734: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
735: // Attr createAttribute(in DOMString name) raises(DOMException);
736: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
737: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
738: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
1.2 parser 739:
1.79 paf 740: /// DOM2
1.2 parser 741:
1.16 parser 742: // ^xdoc.getElementById[elementId]
743: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.79 paf 744:
745: // Node (in Node importedNode, in boolean deep) raises(DOMException)
746: add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);
1.112 paf 747:
1.113 paf 748: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 749: add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);
750:
1.113 paf 751: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 752: add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);
1.99 paf 753:
1.16 parser 754: /// parser
755:
1.54 paf 756: // ^xdoc::create{qualifiedName}
1.95 paf 757: // ^xdoc::create[<some>xml</some>]
758: // ^xdoc::create[URI][<some>xml</some>]
759: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 2);
1.83 paf 760: // for backward compatibility with <=v 1.82 2002/01/31 11:51:46 paf
761: add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);
1.54 paf 762:
763: // ^xdoc::load[some.xml]
1.122 paf 764: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
1.54 paf 765:
1.2 parser 766: // ^xdoc.save[some.xml]
767: // ^xdoc.save[some.xml;options hash]
1.1 parser 768: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
769:
1.2 parser 770: // ^xdoc.string[] <doc/>
771: // ^xdoc.string[options hash] <doc/>
1.1 parser 772: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
773:
1.2 parser 774: // ^xdoc.file[] file with "<doc/>"
775: // ^xdoc.file[options hash] file with "<doc/>"
1.58 paf 776: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
1.1 parser 777:
1.98 paf 778: // ^xdoc.transform[stylesheet file_name/xdoc]
779: // ^xdoc.transform[stylesheet file_name/xdoc;params hash]
1.59 paf 780: add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 781:
1.5 parser 782: }
783:
1.111 paf 784: # else
785:
786: #include "classes.h"
787:
1.1 parser 788: // global variable
789:
1.111 paf 790: DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive
1.1 parser 791:
792: #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