Annotation of parser3/src/classes/xdoc.C, revision 1.171
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.171 ! misha 12: static const char * const IDENT_XDOC_C="$Date: 2011-10-11 13:40:16 $";
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"
1.171 ! misha 31: #include "pa_charsets.h"
1.111 paf 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:
50: DECLARE_CLASS_VAR(xdoc, new MXdoc, 0);
1.61 paf 51:
1.138 paf 52: // helper classes
53:
54: class xmlOutputBuffer_auto_ptr {
55: public:
56: explicit xmlOutputBuffer_auto_ptr(xmlOutputBuffer *_APtr = 0)
57: : _Owns(_APtr != 0), _Ptr(_APtr) {}
58: xmlOutputBuffer_auto_ptr(const xmlOutputBuffer_auto_ptr& _Y)
59: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
60: xmlOutputBuffer_auto_ptr& operator=(const xmlOutputBuffer_auto_ptr& _Y)
61: {if (this != &_Y)
62: {if (_Ptr != _Y.get())
63: {if (_Owns && _Ptr)
64: xmlOutputBufferClose(_Ptr);
65: _Owns = _Y._Owns; }
66: else if (_Y._Owns)
67: _Owns = true;
68: _Ptr = _Y.release(); }
69: return (*this); }
70: ~xmlOutputBuffer_auto_ptr()
71: {if (_Owns && _Ptr)
72: xmlOutputBufferClose(_Ptr); }
73: xmlOutputBuffer& operator*() const
74: {return (*get()); }
75: xmlOutputBuffer *operator->() const
76: {return (get()); }
77: xmlOutputBuffer *get() const
78: {return (_Ptr); }
79: xmlOutputBuffer *release() const
80: {((xmlOutputBuffer_auto_ptr *)this)->_Owns = false;
81: return (_Ptr); }
82: private:
83: bool _Owns;
84: xmlOutputBuffer *_Ptr;
85: };
86:
1.65 paf 87: class xsltTransformContext_auto_ptr {
88: public:
1.67 paf 89: explicit xsltTransformContext_auto_ptr(xsltTransformContext *_APtr = 0)
90: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.65 paf 91: xsltTransformContext_auto_ptr(const xsltTransformContext_auto_ptr& _Y)
92: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
93: xsltTransformContext_auto_ptr& operator=(const xsltTransformContext_auto_ptr& _Y)
94: {if (this != &_Y)
95: {if (_Ptr != _Y.get())
96: {if (_Owns && _Ptr)
97: xsltFreeTransformContext(_Ptr);
98: _Owns = _Y._Owns; }
99: else if (_Y._Owns)
100: _Owns = true;
101: _Ptr = _Y.release(); }
102: return (*this); }
103: ~xsltTransformContext_auto_ptr()
104: {if (_Owns && _Ptr)
105: xsltFreeTransformContext(_Ptr); }
106: xsltTransformContext& operator*() const
107: {return (*get()); }
108: xsltTransformContext *operator->() const
109: {return (get()); }
110: xsltTransformContext *get() const
111: {return (_Ptr); }
112: xsltTransformContext *release() const
113: {((xsltTransformContext_auto_ptr *)this)->_Owns = false;
114: return (_Ptr); }
115: private:
116: bool _Owns;
117: xsltTransformContext *_Ptr;
118: };
1.61 paf 119:
1.65 paf 120: class xsltStylesheet_auto_ptr {
121: public:
1.67 paf 122: explicit xsltStylesheet_auto_ptr(xsltStylesheet *_APtr = 0)
123: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.65 paf 124: xsltStylesheet_auto_ptr(const xsltStylesheet_auto_ptr& _Y)
125: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
126: xsltStylesheet_auto_ptr& operator=(const xsltStylesheet_auto_ptr& _Y)
127: {if (this != &_Y)
128: {if (_Ptr != _Y.get())
129: {if (_Owns && _Ptr)
130: xsltFreeStylesheet(_Ptr);
131: _Owns = _Y._Owns; }
132: else if (_Y._Owns)
133: _Owns = true;
134: _Ptr = _Y.release(); }
135: return (*this); }
136: ~xsltStylesheet_auto_ptr()
137: {if (_Owns && _Ptr)
138: xsltFreeStylesheet(_Ptr); }
139: xsltStylesheet& operator*() const
140: {return (*get()); }
141: xsltStylesheet *operator->() const
142: {return (get()); }
143: xsltStylesheet *get() const
144: {return (_Ptr); }
145: xsltStylesheet *release() const
146: {((xsltStylesheet_auto_ptr *)this)->_Owns = false;
147: return (_Ptr); }
148: private:
149: bool _Owns;
150: xsltStylesheet *_Ptr;
151: };
1.61 paf 152:
1.1 parser 153: // methods
154:
1.149 paf 155: static void writeNode(Request& r, VXdoc& xdoc, xmlNode* node) {
156: if(!node)
1.154 misha 157: throw Exception(PARSER_RUNTIME,
1.149 paf 158: 0,
159: "error creating node"); // OOM, bad name, things like that
1.54 paf 160:
161: // write out result
1.149 paf 162: r.write_no_lang(xdoc.wrap(*node));
163: }
164:
165: struct IdsIteratorInfo {
166: xmlChar *elementId;
167: xmlNode *element;
168: };
169:
170: /* Hash Scanner function for pa_getElementById */
171: extern "C" void // switching to calling convetion of libxml
172: idsHashScanner (void *payload, void *data, xmlChar *name) {
173: IdsIteratorInfo *priv = (IdsIteratorInfo *)data;
174:
175: if (priv->element == NULL && xmlStrEqual (name, priv->elementId))
176: {
177: xmlNode* parent=((xmlID *)payload)->attr->parent;
178: assert(parent);
179: priv->element=parent;
180: }
181: }
182:
183: static xmlNode*
184: pa_getElementById(xmlDoc& xmldoc, xmlChar* elementId) {
185: xmlHashTable *ids = (xmlHashTable *)xmldoc.ids;
186: IdsIteratorInfo iter={elementId, NULL};
187: xmlHashScan(ids, idsHashScanner, &iter);
188: return iter.element;
189: }
190:
191: /*
192: static xmlNode *
193: pa_importNode (xmlDoc& xmldoc, xmlNode& importedNode, bool deep) {
194: xmlNode *result = NULL;
195:
196: switch (importedNode.type) {
197: case XML_ATTRIBUTE_NODE:
198: result = (xmlNode *)xmlCopyProp(xmldoc, (xmlAttr *)importedNode);
199: result.parent=0; // no idea
200: break;
201: case XML_DOCUMENT_FRAG_NODE:
202: case XML_ELEMENT_NODE:
203: case XML_ENTITY_REF_NODE:
204: case XML_PI_NODE:
205: case XML_TEXT_NODE:
206: case XML_CDATA_SECTION_NODE:
207: case XML_COMMENT_NODE:
208: result = xmlCopyNode (importedNode->n, deep);
209: xmlSetTreeDoc (result, priv->n);
210: break;
211: default:
212: *exc = GDOME_NOT_SUPPORTED_ERR;
213: }
214:
215: return result;
1.54 paf 216: }
1.149 paf 217: */
1.54 paf 218:
1.16 parser 219: // Element createElement(in DOMString tagName) raises(DOMException);
1.111 paf 220: static void _createElement(Request& r, MethodParams& params) {
1.168 misha 221: xmlChar* tagName=as_xmlname(r, params, 0, "tagName must be string");
222:
1.111 paf 223: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 224: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 225:
1.149 paf 226: xmlNode *node=xmlNewDocNode(&xmldoc, NULL, tagName, NULL);
227: writeNode(r, vdoc, node);
1.16 parser 228: }
229:
1.113 paf 230: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 231: static void _createElementNS(Request& r, MethodParams& params) {
1.168 misha 232: xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
233: xmlChar* qualifiedName=as_xmlqname(r, params, 1);
234:
1.112 paf 235: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 236: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 237:
1.149 paf 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) {
1.168 misha 261: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
262:
1.111 paf 263: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 264: xmlDoc& xmldoc=vdoc.get_xmldoc();
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) {
1.168 misha 272: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
273:
1.111 paf 274: VXdoc& vdoc=GET_SELF(r, VXdoc);
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) {
1.168 misha 282: xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
283:
1.111 paf 284: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 285: xmlDoc& xmldoc=vdoc.get_xmldoc();
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) {
1.168 misha 293: xmlChar* target=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
294: xmlChar* data=as_xmlchar(r, params, 1, XML_DATA_MUST_BE_STRING);
295:
1.111 paf 296: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 297: xmlDoc& xmldoc=vdoc.get_xmldoc();
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) {
1.168 misha 305: xmlChar* name=as_xmlname(r, params, 0);
306:
1.111 paf 307: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 308: xmlDoc& xmldoc=vdoc.get_xmldoc();
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) {
1.168 misha 316: xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
317: xmlChar* qualifiedName=as_xmlqname(r, params, 1);
318:
1.112 paf 319: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 320: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.112 paf 321:
1.149 paf 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) {
1.168 misha 337: xmlChar* name=as_xmlname(r, params, 0);
338:
1.111 paf 339: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 340: xmlDoc& xmldoc=vdoc.get_xmldoc();
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) {
1.168 misha 348: xmlChar* elementId=as_xmlname(r, params, 0, "elementID must be string");
349:
1.111 paf 350: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.149 paf 351: xmlDoc& xmldoc=vdoc.get_xmldoc();
1.16 parser 352:
1.168 misha 353: if(xmlNode *node=pa_getElementById(xmldoc, elementId))
1.149 paf 354: writeNode(r, vdoc, node);
1.54 paf 355: }
1.79 paf 356:
1.111 paf 357: static void _importNode(Request& r, MethodParams& params) {
1.168 misha 358: xmlNode& importedNode=as_node(params, 0, "importedNode must be node");
359: bool deep=params.as_bool(1, "deep must be bool", r);
360:
1.111 paf 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 *node=xmlDocCopyNode(&importedNode, &xmldoc, deep?1: 0);
365: writeNode(r, vdoc, node);
1.79 paf 366: }
1.168 misha 367:
1.54 paf 368: /*
369: GdomeElement *gdome_doc_createElementNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
370: GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
371: */
1.1 parser 372:
1.111 paf 373: static void _create(Request& r, MethodParams& params) {
374: Charset& source_charset=r.charsets.source();
375: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 376:
1.111 paf 377: Value& param=params[params.count()-1];
1.149 paf 378: xmlDoc* xmldoc;
1.111 paf 379: bool set_encoding=false;
1.95 paf 380: if(param.get_junction()) { // {<?xml?>...}
1.111 paf 381: Temp_lang temp_lang(r, String::L_XML);
1.91 paf 382: const String& xml=r.process_to_string(param);
1.83 paf 383:
1.163 misha 384: String::Body sbody=xml.cstr_to_string_body_untaint(r.flang, 0, &r.charsets);
385: xmldoc=xmlParseMemory(sbody.cstr(), sbody.length());
386:
1.111 paf 387: //printf("document=0x%p\n", document);
1.149 paf 388: if(!xmldoc || xmlHaveGenericErrors())
389: throw XmlException(0);
1.111 paf 390:
391: // must be last action in if, see after if}
1.149 paf 392: } else { // [localName]
1.153 misha 393: if(const String* value = param.get_string()){
394: xmlChar* localName=r.transcode(*value);
1.168 misha 395: if(xmlValidateNCName(localName, 0) != 0)
396: throw XmlException(0, XML_INVALID_LOCAL_NAME, localName);
397:
1.120 paf 398: #if 0
1.153 misha 399: GdomeDocumentType *documentType=gdome_di_createDocumentType (
400: docimpl,
401: r.transcode(qualifiedName),
402: 0/*publicId*/,
403: 0/*systemId*/,
404: &exc);
405: if(!documentType || exc || xmlHaveGenericErrors())
406: throw Exception(
407: method_name,
408: exc);
409: /// +xalan createXMLDecl ?
1.120 paf 410: #endif
1.151 misha 411: xmldoc=xmlNewDoc(0);
412: if(!xmldoc || xmlHaveGenericErrors())
413: throw XmlException(0);
1.168 misha 414:
1.151 misha 415: xmlNode* node=xmlNewChild((xmlNode*)xmldoc, NULL, localName, NULL);
416: if(!node || xmlHaveGenericErrors())
417: throw XmlException(0);
1.103 paf 418:
1.151 misha 419: set_encoding=true;
420: // must be last action in if, see after if}
1.153 misha 421: } else {
1.161 misha 422: VFile* vfile=param.as_vfile(String::L_AS_IS);
1.153 misha 423: xmldoc=xmlParseMemory(vfile->value_ptr(), vfile->value_size());
424: if(!xmldoc || xmlHaveGenericErrors())
425: throw XmlException(0);
1.151 misha 426: }
1.111 paf 427: }
428: // must be first action after if}
429: // replace any previous parsed source
1.149 paf 430: vdoc.set_xmldoc(r.charsets, *xmldoc);
1.95 paf 431:
432: // URI
1.111 paf 433: const char* URI_cstr;
434: if(params.count()>1) { // absolute(param)
435: const String& URI=params.as_string(0, "URI must be string");
1.149 paf 436: URI_cstr=r.absolute(URI).cstr();
1.95 paf 437: } else // default = disk path to requested document
1.111 paf 438: URI_cstr=r.request_info.path_translated;
1.95 paf 439: if(URI_cstr)
1.149 paf 440: xmldoc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
1.95 paf 441:
1.111 paf 442: if(set_encoding) {
443: const char* source_charset_name=source_charset.NAME().cstr();
1.149 paf 444: xmldoc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
1.111 paf 445: }
1.9 parser 446: }
447:
1.111 paf 448: static void _load(Request& r, MethodParams& params) {
449: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.9 parser 450:
1.54 paf 451: // filespec
1.156 misha 452: const String* uri=¶ms.as_string(0, "URI must be string");
1.122 paf 453: const char* uri_cstr;
454: if(uri->pos("://")==STRING_NOT_FOUND) // disk path
1.162 misha 455: uri_cstr=r.absolute(*uri).taint_cstr(String::L_FILE_SPEC);
1.122 paf 456: else // xxx://
1.162 misha 457: uri_cstr=uri->taint_cstr(String::L_AS_IS); // leave as-is for xmlParseFile to handle
1.105 paf 458:
1.157 misha 459: /// @todo!! add SAFE MODE!!
1.149 paf 460: xmlDoc* xmldoc=xmlParseFile(uri_cstr);
461: if(!xmldoc || xmlHaveGenericErrors())
462: throw XmlException(uri);
463:
1.111 paf 464: // must be first action after if}
465: // replace any previous parsed source
1.149 paf 466: vdoc.set_xmldoc(r.charsets, *xmldoc);
1.9 parser 467: }
468:
1.166 misha 469: String::C xdoc2buf(Request& r, VXdoc& vdoc,
470: XDocOutputOptions& oo,
471: const String* file_spec,
472: bool use_source_charset_to_render_and_client_charset_to_write_to_header=false) {
1.171 ! misha 473: Charset* render=0;
! 474: Charset* header=0;
1.140 paf 475: if(use_source_charset_to_render_and_client_charset_to_write_to_header) {
1.171 ! misha 476: render=&r.charsets.source();
! 477: header=&r.charsets.client();
1.140 paf 478: } else {
1.171 ! misha 479: header=render=&charsets.get(oo.encoding->change_case(r.charsets.source(), String::CC_UPPER));
1.140 paf 480: }
1.171 ! misha 481: const char* render_encoding=render->NAME_CSTR();
! 482: const char* header_encoding=header->NAME_CSTR();
1.140 paf 483:
484: xmlCharEncodingHandler *renderer=xmlFindCharEncodingHandler(render_encoding);
485: // UTF-8 renderer contains empty input/output converters,
1.61 paf 486: // which is wrong for xmlOutputBufferCreateIO
1.140 paf 487: // while zero renderer goes perfectly
1.171 ! misha 488: if(render->isUTF8())
1.140 paf 489: renderer=0;
1.61 paf 490:
1.140 paf 491: xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer));
1.138 paf 492:
1.65 paf 493: xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet());
494: if(!stylesheet.get())
1.87 paf 495: throw Exception(0,
1.111 paf 496: 0,
1.61 paf 497: "xsltNewStylesheet failed");
498:
1.143 paf 499: #define OOSTRING2STYLE(name) \
1.149 paf 500: stylesheet->name=oo.name?BAD_CAST xmlMemStrdup((const char*)r.transcode(*oo.name)):0
1.143 paf 501: #define OOBOOL2STYLE(name) \
502: if(oo.name>=0) stylesheet->name=oo.name
1.61 paf 503:
1.143 paf 504: OOSTRING2STYLE(method);
505: OOSTRING2STYLE(encoding);
506: OOSTRING2STYLE(mediaType);
507: // OOSTRING2STYLE(doctypeSystem);
508: // OOSTRING2STYLE(doctypePublic);
509: OOBOOL2STYLE(indent);
510: OOSTRING2STYLE(version);
511: OOBOOL2STYLE(standalone);
512: OOBOOL2STYLE(omitXmlDeclaration);
1.61 paf 513:
1.149 paf 514: xmlDoc& xmldoc=vdoc.get_xmldoc();
515: xmldoc.encoding=BAD_CAST xmlMemStrdup(render_encoding);
1.142 paf 516: if(header_encoding)
517: stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding);
1.149 paf 518: if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet.get())<0
519: || xmlHaveGenericErrors())
520: throw XmlException(0);
1.61 paf 521:
1.138 paf 522: // write out result
1.166 misha 523: char *gnome_str;
524: size_t gnome_length;
1.138 paf 525: if(outputBuffer->conv) {
526: gnome_length=outputBuffer->conv->use;
527: gnome_str=(char *)outputBuffer->conv->content;
528: } else {
529: gnome_length=outputBuffer->buffer->use;
530: gnome_str=(char *)outputBuffer->buffer->content;
531: }
532:
1.166 misha 533: if(file_spec){
1.165 misha 534: file_write(r.charsets,
535: *file_spec,
536: gnome_str,
537: gnome_length,
1.111 paf 538: true/*as_text*/);
1.166 misha 539: return String::C(); // actually, we don't need this output at all
540: } else
541: return String::C(gnome_length ? pa_strdup(gnome_str, gnome_length) : 0, gnome_length);
542: }
1.111 paf 543:
1.166 misha 544: inline HashStringValue* get_options(MethodParams& params, size_t index){
545: return (params.count()>index) ? params.as_hash(index) : 0;
1.1 parser 546: }
547:
1.111 paf 548: static void _file(Request& r, MethodParams& params) {
549: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.1 parser 550:
1.170 misha 551: XDocOutputOptions oo(r, get_options(params, 0), true/* $.name[filename] could be specified by user */);
1.166 misha 552: String::C buf=xdoc2buf(r, vdoc, oo, 0/*file_name. not to file, to memory*/);
553:
1.111 paf 554: VFile& vfile=*new VFile;
555: VHash& vhcontent_type=*new VHash;
556: vhcontent_type.hash().put(
557: value_name,
558: new VString(*oo.mediaType));
559: vhcontent_type.hash().put(
1.126 paf 560: String::Body("charset"),
1.111 paf 561: new VString(*oo.encoding));
562:
563: vfile.set(false/*tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length,
1.170 misha 564: (oo.filename)?oo.filename->taint_cstr(String::L_FILE_SPEC):0, &vhcontent_type);
1.166 misha 565:
1.169 misha 566: vfile.set_mode(true/*text*/);
567:
1.166 misha 568: // write out result
1.58 paf 569: r.write_no_lang(vfile);
1.63 paf 570: }
571:
1.111 paf 572: static void _save(Request& r, MethodParams& params) {
573: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.63 paf 574:
1.155 misha 575: const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));
1.63 paf 576:
1.166 misha 577: XDocOutputOptions oo(r, get_options(params, 1));
578: xdoc2buf(r, vdoc, oo, &file_spec);
1.63 paf 579: }
580:
1.111 paf 581: static void _string(Request& r, MethodParams& params) {
582: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.166 misha 583:
584: XDocOutputOptions oo(r, get_options(params, 0));
585: String::C buf=xdoc2buf(r, vdoc, oo,
586: 0/*file_name. not to file, to memory*/,
1.140 paf 587: true/*use source charset to render, client charset to put to header*/);
1.166 misha 588:
1.63 paf 589: // write out result
1.166 misha 590: r.write_no_lang(String(buf, String::L_AS_IS));
1.1 parser 591: }
1.58 paf 592:
1.111 paf 593: #ifndef DOXYGEN
594: struct Add_xslt_param_info {
595: Request* r;
1.149 paf 596: Array<const xmlChar*>* strings;
597: const xmlChar** current_transform_param;
1.111 paf 598: };
599: #endif
600: static void add_xslt_param(
601: HashStringValue::key_type attribute,
602: HashStringValue::value_type meaning,
603: Add_xslt_param_info* info) {
1.149 paf 604: xmlChar* s;
605: *info->current_transform_param++=(s=info->r->transcode(attribute)); *info->strings+=s;
606: *info->current_transform_param++=(s=info->r->transcode(meaning->as_string())); *info->strings+=s;
1.111 paf 607: }
1.132 paf 608:
1.111 paf 609: static VXdoc& _transform(Request& r, const String* stylesheet_source,
1.149 paf 610: VXdoc& vdoc, xsltStylesheetPtr stylesheet, const xmlChar** transform_params)
1.132 paf 611: {
1.149 paf 612: xmlDoc& xmldoc=vdoc.get_xmldoc();
613:
1.65 paf 614: xsltTransformContext_auto_ptr transformContext(
1.149 paf 615: xsltNewTransformContext(stylesheet, &xmldoc));
1.90 paf 616: // make params literal
1.111 paf 617: if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
1.90 paf 618: transformContext->globalVars = xmlHashCreate(20);
1.149 paf 619: xsltQuoteUserParams(transformContext.get(), (const char**)transform_params);
1.90 paf 620: // do transform
1.59 paf 621: xmlDoc *transformed=xsltApplyStylesheetUser(
622: stylesheet,
1.149 paf 623: &xmldoc,
1.90 paf 624: 0/*already quoted-inserted transform_params*/,
1.111 paf 625: 0/*const char* output*/,
1.59 paf 626: 0/*FILE *profile*/,
1.65 paf 627: transformContext.get());
1.149 paf 628: if(!transformed || xmlHaveGenericErrors())
629: throw XmlException(stylesheet_source);
1.42 paf 630:
1.61 paf 631: //gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing
632: transformed->type=XML_DOCUMENT_NODE;
1.167 misha 633:
1.59 paf 634: // constructing result
1.167 misha 635: return *new VXdoc(r.charsets, *transformed);
1.93 paf 636: }
1.111 paf 637: static void _transform(Request& r, MethodParams& params) {
638: VXdoc& vdoc=GET_SELF(r, VXdoc);
1.93 paf 639:
640: // params
1.149 paf 641: Array<const xmlChar*> transform_strings;
642: const xmlChar** transform_params=0;
1.166 misha 643: if(params.count()>1)
644: if(HashStringValue* hash=params.as_hash(1)) {
645: transform_params=new(UseGC) const xmlChar*[hash->count()*2+1];
646: Add_xslt_param_info info={
647: &r,
648: &transform_strings,
649: transform_params
650: };
651: hash->for_each<Add_xslt_param_info*>(add_xslt_param, &info);
652: transform_params[hash->count()*2]=0;
653: }
1.93 paf 654:
1.111 paf 655: VXdoc* result;
1.164 misha 656: if(Value *vxdoc=params[0].as(VXDOC_TYPE)) { // stylesheet (xdoc)
1.149 paf 657: xmlDoc& stylesheetdoc=static_cast<VXdoc *>(vxdoc)->get_xmldoc();
1.93 paf 658: // compile xdoc stylesheet
1.149 paf 659: xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(&stylesheetdoc));
660: if(xmlHaveGenericErrors())
661: throw XmlException(0);
1.93 paf 662: if(!stylesheet_ptr.get())
663: throw Exception("xml",
1.111 paf 664: 0,
1.93 paf 665: "stylesheet failed to compile");
1.128 paf 666: // strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
667: // we don't need that
668: stylesheet_ptr->doc=0;
1.93 paf 669:
670: // transform!
1.111 paf 671: result=&_transform(r, 0,
1.93 paf 672: vdoc, stylesheet_ptr.get(),
673: transform_params);
674: } else { // stylesheet (file name)
675: // extablish stylesheet connection
676: const String& stylesheet_filespec=
1.111 paf 677: r.absolute(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
1.125 paf 678: Stylesheet_connection_ptr connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.93 paf 679:
680: // load and compile file to stylesheet [or get cached if any]
681: // transform!
1.122 paf 682: result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(),
1.93 paf 683: transform_params);
684: }
685:
1.59 paf 686: // write out result
1.93 paf 687: r.write_no_lang(*result);
1.1 parser 688: }
689:
1.16 parser 690: // constructor
1.2 parser 691:
1.92 paf 692: /// @test how to create empty type html?
1.111 paf 693: MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, xnode_class) {
1.16 parser 694: /// DOM1
1.2 parser 695:
1.16 parser 696: // Element createElement(in DOMString tagName) raises(DOMException);
697: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
698: // DocumentFragment createDocumentFragment();
699: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
700: // Text createTextNode(in DOMString data);
701: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
702: // Comment createComment(in DOMString data);
703: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
704: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
705: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
706: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
707: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
708: // Attr createAttribute(in DOMString name) raises(DOMException);
709: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
710: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
711: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
1.2 parser 712:
1.79 paf 713: /// DOM2
1.2 parser 714:
1.16 parser 715: // ^xdoc.getElementById[elementId]
716: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.79 paf 717:
718: // Node (in Node importedNode, in boolean deep) raises(DOMException)
719: add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);
1.112 paf 720:
1.113 paf 721: // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 722: add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);
723:
1.113 paf 724: // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
1.112 paf 725: add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);
1.99 paf 726:
1.16 parser 727: /// parser
728:
1.54 paf 729: // ^xdoc::create{qualifiedName}
1.95 paf 730: // ^xdoc::create[<some>xml</some>]
731: // ^xdoc::create[URI][<some>xml</some>]
732: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 2);
1.83 paf 733: // for backward compatibility with <=v 1.82 2002/01/31 11:51:46 paf
734: add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);
1.54 paf 735:
736: // ^xdoc::load[some.xml]
1.122 paf 737: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
1.54 paf 738:
1.2 parser 739: // ^xdoc.save[some.xml]
740: // ^xdoc.save[some.xml;options hash]
1.1 parser 741: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
742:
1.2 parser 743: // ^xdoc.string[] <doc/>
744: // ^xdoc.string[options hash] <doc/>
1.1 parser 745: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
746:
1.2 parser 747: // ^xdoc.file[] file with "<doc/>"
748: // ^xdoc.file[options hash] file with "<doc/>"
1.58 paf 749: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
1.1 parser 750:
1.98 paf 751: // ^xdoc.transform[stylesheet file_name/xdoc]
752: // ^xdoc.transform[stylesheet file_name/xdoc;params hash]
1.59 paf 753: add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 754:
1.5 parser 755: }
756:
1.111 paf 757: # else
758:
759: #include "classes.h"
760:
1.1 parser 761: // global variable
762:
1.111 paf 763: DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive
1.1 parser 764:
765: #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