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