Annotation of parser3/src/classes/xdoc.C, revision 1.56
1.1 parser 1: /** @file
1.2 parser 2: Parser: @b xdoc parser class.
1.1 parser 3:
4: Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
1.43 paf 5: Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
1.1 parser 6:
1.56 ! paf 7: $Id: xdoc.C,v 1.55 2001/12/28 18:12:30 paf Exp $
1.1 parser 8: */
1.30 parser 9: #include "pa_types.h"
1.1 parser 10: #include "classes.h"
11: #ifdef XML
12:
13: #include "pa_request.h"
14: #include "pa_vxdoc.h"
1.54 paf 15: //#include "pa_stylesheet_manager.h"
16: //#include "pa_stylesheet_connection.h"
1.53 paf 17: #include "pa_charset.h"
1.1 parser 18: #include "pa_vfile.h"
19: #include "xnode.h"
20:
21: // defines
22:
23: #define XDOC_CLASS_NAME "xdoc"
24:
25: #define XDOC_OUTPUT_METHOD_OPTION_NAME "method"
26: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"
27: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"
28: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"
29: #define XDOC_OUTPUT_DEFAULT_INDENT 4
30:
31: // class
32:
33: class MXdoc : public MXnode {
34: public: // VStateless_class
1.54 paf 35: Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool, 0); }
1.1 parser 36:
37: public:
38: MXdoc(Pool& pool);
39:
40: public: // Methoded
41: bool used_directly() { return true; }
1.5 parser 42: void configure_admin(Request& r);
1.1 parser 43: };
44:
45: // methods
46:
1.54 paf 47: static void writeNode(Request& r, const String& method_name, GdomeNode *node,
48: GdomeException exc) {
49: if(!node || exc)
50: throw Exception(0, 0,
51: &method_name,
52: exc);
53:
54: Pool& pool=r.pool();
55:
56: // write out result
57: VXnode& result=*new(pool) VXnode(pool, node);
58: r.write_no_lang(result);
59: }
60:
1.16 parser 61: // Element createElement(in DOMString tagName) raises(DOMException);
62: static void _createElement(Request& r, const String& method_name, MethodParams *params) {
63: Pool& pool=r.pool();
64: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
65:
1.39 paf 66: const String& tagName=params->as_string(0, "tagName must be string");
1.16 parser 67:
1.54 paf 68: GdomeException exc;
69: GdomeNode *node=
70: (GdomeNode *)gdome_doc_createElement(vdoc.get_document(&method_name),
71: pool.transcode(tagName),
72: &exc);
73: writeNode(r, method_name, node, exc);
1.16 parser 74: }
75:
76: // DocumentFragment createDocumentFragment()
1.26 parser 77: static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {
1.16 parser 78: Pool& pool=r.pool();
79: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
80:
1.54 paf 81: GdomeException exc;
82: GdomeNode *node=
83: (GdomeNode *)gdome_doc_createDocumentFragment(
84: vdoc.get_document(&method_name),
85: &exc);
86: writeNode(r, method_name, node, exc);
1.16 parser 87: }
88:
89: // Text createTextNode(in DOMString data);
90: static void _createTextNode(Request& r, const String& method_name, MethodParams *params) {
91: Pool& pool=r.pool();
92: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
93:
1.40 paf 94: const String& data=params->as_string(0, "data must be string");
1.16 parser 95:
1.54 paf 96: GdomeException exc;
97: GdomeNode *node=(GdomeNode *)gdome_doc_createTextNode(
98: vdoc.get_document(&method_name),
99: pool.transcode(data),
100: &exc);
101: writeNode(r, method_name, node, exc);
1.16 parser 102: }
103:
104: // Comment createComment(in DOMString data)
105: static void _createComment(Request& r, const String& method_name, MethodParams *params) {
106: Pool& pool=r.pool();
107: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
108:
1.26 parser 109: const String& data=params->as_string(0, "data must be string");
1.16 parser 110:
1.54 paf 111: GdomeException exc;
112: GdomeNode *node=(GdomeNode *)gdome_doc_createComment(
113: vdoc.get_document(&method_name),
114: pool.transcode(data),
115: &exc);
116: writeNode(r, method_name, node, exc);
1.16 parser 117: }
118:
119: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
120: static void _createCDATASection(Request& r, const String& method_name, MethodParams *params) {
121: Pool& pool=r.pool();
122: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
123:
1.26 parser 124: const String& data=params->as_string(0, "data must be string");
1.16 parser 125:
1.54 paf 126: GdomeException exc;
127: GdomeNode *node=(GdomeNode *)gdome_doc_createCDATASection(
128: vdoc.get_document(&method_name),
129: pool.transcode(data),
130: &exc);
131: writeNode(r, method_name, node, exc);
1.16 parser 132: }
133:
134: // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
135: static void _createProcessingInstruction(Request& r, const String& method_name, MethodParams *params) {
136: Pool& pool=r.pool();
137: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
138:
1.26 parser 139: const String& target=params->as_string(0, "data must be string");
140: const String& data=params->as_string(1, "data must be string");
1.16 parser 141:
1.54 paf 142: GdomeException exc;
143: GdomeNode *node=(GdomeNode *)gdome_doc_createProcessingInstruction(
144: vdoc.get_document(&method_name),
145: pool.transcode(target),
146: pool.transcode(data),
147: &exc);
148: writeNode(r, method_name, node, exc);
1.16 parser 149: }
150:
151: // Attr createAttribute(in DOMString name) raises(DOMException);
152: static void _createAttribute(Request& r, const String& method_name, MethodParams *params) {
153: Pool& pool=r.pool();
154: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
155:
1.26 parser 156: const String& name=params->as_string(0, "name must be string");
1.16 parser 157:
1.54 paf 158: GdomeException exc;
159: GdomeNode *node=(GdomeNode *)gdome_doc_createAttribute(
160: vdoc.get_document(&method_name),
161: pool.transcode(name),
162: &exc);
163: writeNode(r, method_name, node, exc);
1.16 parser 164: }
165: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
166: static void _createEntityReference(Request& r, const String& method_name, MethodParams *params) {
167: Pool& pool=r.pool();
168: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
169:
1.26 parser 170: const String& name=params->as_string(0, "name must be string");
1.16 parser 171:
1.54 paf 172: GdomeException exc;
173: GdomeNode *node=(GdomeNode *)gdome_doc_createEntityReference(
174: vdoc.get_document(&method_name),
175: pool.transcode(name),
176: &exc);
177: writeNode(r, method_name, node, exc);
1.16 parser 178: }
179:
180: static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {
181: Pool& pool=r.pool();
182: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
183:
1.54 paf 184: const String& name=params->as_string(0, "name must be string");
1.16 parser 185:
1.54 paf 186: GdomeException exc;
1.16 parser 187: VHash& result=*new(pool) VHash(pool);
1.54 paf 188: if(GdomeNodeList *nodes=
189: gdome_doc_getElementsByTagName(
190: vdoc.get_document(&method_name),
191: pool.transcode(name),
192: &exc)) {
193: gulong length=gdome_nl_length(nodes, &exc);
194: for(gulong i=0; i<length; i++) {
1.16 parser 195: String& skey=*new(pool) String(pool);
196: {
197: char *buf=(char *)pool.malloc(MAX_NUMBER);
198: snprintf(buf, MAX_NUMBER, "%d", i);
199: skey << buf;
200: }
201:
1.54 paf 202: result.hash(0).put(skey, new(pool) VXnode(pool, gdome_nl_item(nodes, i, &exc)));
1.16 parser 203: }
204: }
205:
206: // write out result
207: r.write_no_lang(result);
208: }
209:
210: static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams *params) {
211: Pool& pool=r.pool();
212: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
213:
214: // namespaceURI;localName
1.54 paf 215: const String& namespaceURI=params->as_string(0, "namespaceURI must be string");
216: const String& localName=params->as_string(0, "localName must be string");
1.16 parser 217:
1.54 paf 218: GdomeException exc;
1.16 parser 219: VHash& result=*new(pool) VHash(pool);
1.54 paf 220: if(GdomeNodeList *nodes=
221: gdome_doc_getElementsByTagNameNS(
222: vdoc.get_document(&method_name),
223: pool.transcode(namespaceURI),
224: pool.transcode(localName),
225: &exc)) {
226: gulong length=gdome_nl_length(nodes, &exc);
227: for(gulong i=0; i<length; i++) {
1.16 parser 228: String& skey=*new(pool) String(pool);
229: {
230: char *buf=(char *)pool.malloc(MAX_NUMBER);
231: snprintf(buf, MAX_NUMBER, "%d", i);
232: skey << buf;
233: }
234:
1.54 paf 235: result.hash(0).put(skey, new(pool) VXnode(pool, gdome_nl_item(nodes, i, &exc)));
1.16 parser 236: }
237: }
238:
1.54 paf 239:
1.16 parser 240: // write out result
241: r.write_no_lang(result);
242: }
243:
1.54 paf 244: static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
245: Pool& pool=r.pool();
246: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.16 parser 247:
1.54 paf 248: // elementId
249: const String& elementId=params->as_string(0, "elementID must be string");
1.1 parser 250:
1.54 paf 251: GdomeException exc;
252: if(GdomeNode *node=(GdomeNode *)gdome_doc_getElementById(
253: vdoc.get_document(&method_name),
254: pool.transcode(elementId),
255: &exc)) {
256: // write out result
257: VXnode& result=*new(pool) VXnode(pool, node);
258: r.write_no_lang(result);
259: } else if(exc)
260: throw Exception(0, 0,
261: &method_name,
262: exc);
263: }
264: /*
265: GdomeNode *gdome_doc_importNode (GdomeDocument *self, GdomeNode *importedNode, GdomeBoolean deep, GdomeException *exc);
266: GdomeElement *gdome_doc_createElementNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
267: GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
268: GdomeNodeList *gdome_doc_getElementsByTagNameNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *localName, GdomeException *exc);
269: */
1.1 parser 270:
271:
1.54 paf 272: static void _create(Request& r, const String& method_name, MethodParams *params) {
273: //_asm int 3;
274: Pool& pool=r.pool();
275: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 276:
1.54 paf 277: const String& qualifiedName=params->as_string(0, "qualifiedName must be string");
1.1 parser 278:
1.54 paf 279: GdomeException exc;
280: /*
281: GdomeDocumentType *documentType=gdome_di_createDocumentType (
282: docimpl,
283: pool.transcode(qualifiedName),
284: 0/*publicId* /,
285: 0/*systemId* /,
286: &exc);
287: if(!documentType || exc)
288: throw Exception(0, 0,
289: &method_name,
290: exc);
291: */
292: GdomeDocument *document=gdome_di_createDocument (domimpl,
293: 0/*namespaceURI*/,
294: pool.transcode(qualifiedName),
295: 0/*doctype*/,
296: &exc);
297: if(!document || exc)
298: throw Exception(0, 0,
299: &method_name,
300: exc);
1.1 parser 301:
1.54 paf 302: /// +createXMLDecl ?
303: //document.appendChild(document.createElement(*pool.transcode(qualifiedName)));
1.9 parser 304:
1.54 paf 305: // replace any previous parsed source
306: vdoc.set_document(document);
307: }
1.9 parser 308:
1.56 ! paf 309: /// @test xmlSAXParseMemory(NULL<<error handler subst, buffer, size, 0)
1.54 paf 310: static void _set(Request& r, const String& method_name, MethodParams *params) {
311: // _asm int 3;
312: Pool& pool=r.pool();
313: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.9 parser 314:
1.54 paf 315: Value& vxml=params->as_junction(0, "xml must be code");
316: Temp_lang temp_lang(r, String::UL_XML);
317: const String& xml=r.process(vxml).as_string();
1.9 parser 318:
1.54 paf 319: GdomeException exc;
320: GdomeDocument *document=gdome_di_createDocFromMemory(domimpl,
321: xml.cstr(String::UL_UNSPECIFIED, r.connection),
1.55 paf 322: GDOME_LOAD_PARSING
323: /* GDOME_LOAD_VALIDATING */
1.54 paf 324: /*|GDOME_LOAD_SUBSTITUTE_ENTITIES */,
325: &exc);
326: if(!document || exc)
327: throw Exception(0, 0,
328: &method_name,
329: exc);
1.9 parser 330:
1.54 paf 331: // replace any previous parsed source
332: vdoc.set_document(document);
1.9 parser 333: }
334:
1.54 paf 335: static void _load(Request& r, const String& method_name, MethodParams *params) {
336: Pool& pool=r.pool();
337: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.9 parser 338:
1.54 paf 339: // filespec
340: const String& file_name=params->as_string(0, "uri must be string");
341: const String& uri=r.absolute(file_name);
342:
343: GdomeException exc;
344: GdomeDocument *document=gdome_di_createDocFromURI(domimpl,
345: uri.cstr(),
1.55 paf 346: GDOME_LOAD_PARSING
347: /*GDOME_LOAD_VALIDATING */
1.54 paf 348: /*|GDOME_LOAD_SUBSTITUTE_ENTITIES */,
349: &exc);
350: if(!document || exc)
351: throw Exception(0, 0,
352: &method_name,
353: exc);
1.9 parser 354:
1.54 paf 355: // replace any previous parsed source
356: vdoc.set_document(document);
1.9 parser 357: }
358:
1.54 paf 359: /*
1.46 paf 360: static void param_option_over_output_option(Pool& pool,
361: Hash *param_options, const char *option_name,
362: XalanDOMString& output_option) {
363: if(Value *value=static_cast<Value *>(param_options->get(*new(pool)
364: String(pool, option_name)))) {
365: output_option.clear();
366: output_option.append(value->as_string().cstr());
367: }
368: }
369: static void param_option_over_output_option(Pool& pool,
370: Hash *param_options, const char *option_name,
371: bool& output_option) {
372: if(Value *value=static_cast<Value *>(param_options->get(*new(pool)
373: String(pool, option_name)))) {
374: const String& s=value->as_string();
375: if(s=="yes")
376: output_option=true;
377: else if(s=="no")
378: output_option=false;
379: else
380: throw Exception(0, 0,
381: &s,
382: "%s must be either 'yes' or 'no'", option_name);
383: }
384: }
385:
1.54 paf 386: static std::auto_ptr<FormatterListener> create_optioned_listener(
1.46 paf 387: Pool& pool, const String& method_name, MethodParams *params, int index,
1.52 paf 388: VXdoc::Output_options& oo, Writer& writer) {
1.46 paf 389: /*
390: XalanDOMString encoding;
391: XalanDOMString mediaType;
392: XalanDOMString doctypeSystem;
393: XalanDOMString doctypePublic;
394: bool doIndent;
395: XalanDOMString version;
396: XalanDOMString standalone;
397: bool xmlDecl;
1.54 paf 398: * /
1.9 parser 399:
1.46 paf 400: /*
401: <xsl:output
402: !method = "xml" | "html" | "text" | qname-but-not-ncname
403: !version = nmtoken
404: !encoding = string
405: !omit-xml-declaration = "yes" | "no"
406: !standalone = "yes" | "no"
407: !doctype-public = string
408: !doctype-system = string
409: cdata-section-elements = qnames
410: !indent = "yes" | "no"
411: !media-type = string />
1.54 paf 412: * /
1.9 parser 413:
1.46 paf 414: /*
415: fToXML->setStripCData(stripCData);
416: fToXML->setEscapeCData(escapeCData);
1.54 paf 417: * /
1.1 parser 418:
1.46 paf 419: // configuring with options from parameter...
1.1 parser 420: if(params->size()>index) {
1.20 parser 421: Value& voptions=params->as_no_junction(index, "options must be string");
1.1 parser 422: if(voptions.is_defined()) {
1.34 parser 423: if(Hash *options=voptions.get_hash(&method_name)) {
1.1 parser 424: // $.method[xml|html|text]
425: if(Value *vmethod=static_cast<Value *>(options->get(*new(pool)
426: String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
1.46 paf 427: oo.method=vmethod->as_string().cstr();
1.1 parser 428:
1.46 paf 429: // $.version[1.0]
430: param_option_over_output_option(pool, options, "version", oo.version);
1.1 parser 431: // $.encoding[windows-1251|...]
1.46 paf 432: param_option_over_output_option(pool, options, "encoding", oo.encoding);
433: // $.omit-xml-declaration[yes|no]
434: bool omit_xml_declaration=!oo.xmlDecl;
435: param_option_over_output_option(pool, options, "omit-xml-declaration", omit_xml_declaration);
436: oo.xmlDecl=!omit_xml_declaration;
437: // $.standalone[yes|no]
438: param_option_over_output_option(pool, options, "standalone", oo.standalone);
439: // $.doctype-public[?]
440: param_option_over_output_option(pool, options, "doctype-public", oo.doctypePublic);
441: // $.doctype-system[?]
442: param_option_over_output_option(pool, options, "doctype-system", oo.doctypeSystem);
443: // $.indent[yes|no]
444: param_option_over_output_option(pool, options, "indent", oo.doIndent);
445: // $.media-type[text/{html|xml|plain}]
446: param_option_over_output_option(pool, options, "media-type", oo.mediaType);
1.19 parser 447: }
1.1 parser 448: }
449: }
450:
1.46 paf 451: // default encoding from pool
452: if(oo.encoding.empty())
1.53 paf 453: oo.encoding.append(pool.get_source_charset().name().cstr());
1.46 paf 454: // default method=xml
455: if(!oo.method)
456: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML;
457:
458: if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)==0) {
459: if(oo.mediaType.empty())
460: oo.mediaType.append("text/xml");
1.52 paf 461: return std::auto_ptr<FormatterListener>(new FormatterToXML(writer,
1.46 paf 462: oo.version,
463: oo.doIndent,
1.1 parser 464: XDOC_OUTPUT_DEFAULT_INDENT, // indent
1.46 paf 465: oo.encoding,
466: oo.mediaType,
467: oo.doctypeSystem,
468: oo.doctypePublic,
469: oo.xmlDecl,
470: oo.standalone
1.49 paf 471: ));
1.46 paf 472: } else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)==0) {
473: if(oo.mediaType.empty())
474: oo.mediaType.append("text/html");
1.52 paf 475: return std::auto_ptr<FormatterListener>(new FormatterToHTML(writer,
1.46 paf 476: oo.encoding,
477: oo.mediaType,
478: oo.doctypeSystem,
479: oo.doctypePublic,
480: oo.doIndent,
481: XDOC_OUTPUT_DEFAULT_INDENT, // indent
482: oo.version,
483: oo.standalone,
484: oo.xmlDecl
1.49 paf 485: ));
1.46 paf 486: } else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT)==0) {
487: if(oo.mediaType.empty())
488: oo.mediaType.append("text/plain");
1.52 paf 489: return std::auto_ptr<FormatterListener>(new FormatterToText(writer,
1.46 paf 490: oo.encoding
1.49 paf 491: ));
1.1 parser 492: } else
1.29 parser 493: throw Exception(0, 0,
1.46 paf 494: &method_name,
1.1 parser 495: XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
496: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
497: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "
498: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "'");
1.52 paf 499:
500: // never reached
1.1 parser 501: }
1.54 paf 502: */
1.1 parser 503:
504: static void _save(Request& r, const String& method_name, MethodParams *params) {
505: Pool& pool=r.pool();
1.46 paf 506: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 507:
1.20 parser 508: const String& file_name=params->as_string(0, "file name must be string");
1.54 paf 509: const String& filespec=r.absolute(file_name);
1.1 parser 510:
1.54 paf 511: GdomeException exc;
512: if(!gdome_di_saveDocToFile(domimpl,
513: vdoc.get_document(&method_name),
514: filespec.cstr(String::UL_FILE_SPEC),
515: GDOME_SAVE_LIBXML_INDENT /*GDOME_SAVE_STANDARD */,
516: &exc))
517: throw Exception(0, 0,
518: &method_name,
519: exc);
1.1 parser 520: }
521:
522: static void _string(Request& r, const String& method_name, MethodParams *params) {
523: Pool& pool=r.pool();
1.21 parser 524: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 525:
1.54 paf 526: char *mem;
527: GdomeException exc;
528: if(!gdome_di_saveDocToMemory(domimpl,
529: vdoc.get_document(&method_name),
530: &mem,
531: GDOME_SAVE_LIBXML_INDENT /*GDOME_SAVE_STANDARD */,
532: &exc))
533: throw Exception(0, 0,
534: &method_name,
535: exc);
536:
537: // move to pool memory
538: size_t size=strlen(mem);
539: char *buf=(char *)pool.malloc(size);
540: memcpy(buf, mem, size);
541: g_free(mem);
542: // write out result
543: r.write_no_lang(*new(pool) String(pool, buf, size));
1.1 parser 544: }
545:
1.54 paf 546: /*
1.1 parser 547: static void _file(Request& r, const String& method_name, MethodParams *params) {
548: Pool& pool=r.pool();
1.46 paf 549: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 550: VXnode& vnode=*static_cast<VXnode *>(r.self);
551:
552: // node
1.54 paf 553: GdomeNode *node=vnode.get_node(pool, &method_name);
1.1 parser 554:
555: try {
1.46 paf 556: VXdoc::Output_options oo(vdoc.output_options);
1.1 parser 557: String& parserString=*new(pool) String(pool);
558: ParserStringXalanOutputStream stream(parserString);
559: XalanOutputStreamPrintWriter writer(stream);
1.52 paf 560: std::auto_ptr<FormatterListener> formatterListener=
561: create_optioned_listener(pool, method_name, params, 0,
562: oo, writer);
1.1 parser 563: FormatterTreeWalker treeWalker(*formatterListener);
564: treeWalker.traverse(&node); // Walk that node and produce the XML...
565:
566: // write out result
567: VFile& vfile=*new(pool) VFile(pool);
568: const char *cstr=parserString.cstr();
1.46 paf 569: const String& scontent_type=pool.transcode(oo.mediaType);
1.1 parser 570: Value *vcontent_type;
1.46 paf 571: if(oo.encoding.empty())
572: vcontent_type=new(pool) VString(scontent_type);
573: else {
1.1 parser 574: VHash *vhcontent_type=new(pool) VHash(pool);
1.46 paf 575: vhcontent_type->hash(&method_name).put(*value_name, new(pool) VString(scontent_type));
576: const String& scharset=pool.transcode(oo.encoding);
577: vhcontent_type->hash(&method_name).put(*new(pool) String(pool, "charset"), new(pool) VString(scharset));
1.1 parser 578: vcontent_type=vhcontent_type;
1.46 paf 579: }
580:
1.54 paf 581: vfile.set(false/*tainted* /, cstr, strlen(cstr), 0/*file_name* /, vcontent_type);
1.1 parser 582: r.write_no_lang(vfile);
583: } catch(const XSLException& e) {
1.32 parser 584: Exception::provide_source(pool, &method_name, e);
1.1 parser 585: }
586: }
1.54 paf 587: */
588: /*
1.38 paf 589: /// @test lang=String::UL_UNSPECIFIED?
1.1 parser 590: static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,
591: void *info) {
1.13 parser 592: XalanTransformer2& transformer=*static_cast<XalanTransformer2 *>(info);
1.38 paf 593: const char *attribute_cstr=aattribute.cstr(String::UL_UNSPECIFIED);
594: const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr(String::UL_UNSPECIFIED);
1.1 parser 595:
596: transformer.setStylesheetParam(
597: XalanDOMString(attribute_cstr),
598: XalanDOMString(meaning_cstr));
599: }
1.24 parser 600: static void _transform(Request& r, const String& method_name, MethodParams *params) {
601: Pool& pool=r.pool();
602: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
603:
604: // params
605: if(params->size()>1) {
606: Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
607: if(vparams.is_defined())
1.34 parser 608: if(Hash *params=vparams.get_hash(&method_name))
1.24 parser 609: params->for_each(add_xslt_param, &vdoc.transformer());
610: else
1.29 parser 611: throw Exception(0, 0,
1.24 parser 612: &method_name,
613: "transform parameters parameter must be hash");
614: }
615:
616: // stylesheet
617: const String& stylesheet_file_name=params->as_string(0, "file name must be string");
618: const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
619: //_asm int 3;
1.32 parser 620: Stylesheet_connection& connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.24 parser 621:
622: // target
1.35 paf 623: XalanDocument* target=vdoc.parser_xerces_liaison().createDocument();
1.24 parser 624:
625: // transform
626: try {
1.36 paf 627: // note:
628: // actually, never found any difference between the two
629: // but still there some extra "xerces" words at start of transform body
630: // wich were originally "xalan"
631: // not daring to change that
1.46 paf 632:
1.54 paf 633: const XalanCompiledStylesheet& stylesheet=connection.stylesheet(false/*nocache* /);
1.35 paf 634: if(vdoc.has_parsed_source()) { // set|load, not create?
635: vdoc.transformer().transform2(
636: vdoc.get_parsed_source(pool, &method_name),
1.46 paf 637: &stylesheet,
1.35 paf 638: target);
639: } else {
640: target=vdoc.parser_xerces_liaison().createDocument();
641: vdoc.transformer().transform2(
1.54 paf 642: vdoc.get_document(&method_name),
1.46 paf 643: &stylesheet,
1.35 paf 644: target);
645: }
1.54 paf 646: VXdoc& result=*new(pool) VXdoc(pool, target, false/*owns not* /);
1.46 paf 647: // write out result
648: r.write_no_lang(result);
649: //
650: if(const StylesheetRoot *stylesheetRoot=stylesheet.getStylesheetRoot()) {
651: /*
652: <xsl:output
653: !method = "xml" | "html" | "text"
654: X| qname-but-not-ncname
655: !version = nmtoken
656: !encoding = string
657: !omit-xml-declaration = "yes" | "no"
658: !standalone = "yes" | "no"
659: !doctype-public = string
660: !doctype-system = string
661: cdata-section-elements = qnames
662: !indent = "yes" | "no"
663: !media-type = string />
1.54 paf 664: * /
1.46 paf 665:
666: VXdoc::Output_options& oo=result.output_options;
667: oo.encoding=stylesheetRoot->m_encoding;
668: oo.mediaType=stylesheetRoot->m_mediatype;
669: oo.doctypeSystem=stylesheetRoot->m_doctypeSystem;
670: oo.doctypePublic=stylesheetRoot->m_doctypePublic;
671: oo.doIndent=stylesheetRoot->m_indentResult;
672: oo.version=stylesheetRoot->m_version;
673: oo.standalone=stylesheetRoot->m_standalone;
674: oo.xmlDecl=!stylesheetRoot->m_omitxmlDecl;
675:
676: switch(stylesheetRoot->getOutputMethod()) {
677: case FormatterListener::OUTPUT_METHOD_HTML:
678: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML; break;
679: case FormatterListener::OUTPUT_METHOD_TEXT:
680: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT; break;
681: case FormatterListener::OUTPUT_METHOD_NONE:
682: case FormatterListener::OUTPUT_METHOD_XML:
683: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML; break;
684: default:
685: throw Exception(0, 0,
686: &method_name,
687: "unsupported output method specified");
688: break; // never
689: }
690: }
1.13 parser 691: }
692: catch (XSLException& e) {
693: connection.close();
1.32 parser 694: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 695: }
696: catch (SAXParseException& e) {
697: connection.close();
1.32 parser 698: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 699: }
700: catch (SAXException& e) {
701: connection.close();
1.32 parser 702: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 703: }
704: catch (XMLException& e) {
705: connection.close();
1.32 parser 706: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 707: }
1.16 parser 708: catch(const XalanDOMException& e) {
1.13 parser 709: connection.close();
1.32 parser 710: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 711: }
1.42 paf 712:
713: // close
714: connection.close();
1.1 parser 715: }
1.54 paf 716: */
1.1 parser 717:
1.16 parser 718: // constructor
1.2 parser 719:
1.16 parser 720: MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
721: set_name(*NEW String(pool(), XDOC_CLASS_NAME));
1.2 parser 722:
1.16 parser 723: /// @test how to create empty type html?
1.2 parser 724:
1.16 parser 725: /// DOM1
1.2 parser 726:
1.16 parser 727: // Element createElement(in DOMString tagName) raises(DOMException);
728: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
729: // DocumentFragment createDocumentFragment();
730: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
731: // Text createTextNode(in DOMString data);
732: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
733: // Comment createComment(in DOMString data);
734: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
735: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
736: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
737: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
738: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
739: // Attr createAttribute(in DOMString name) raises(DOMException);
740: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
741: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
742: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
743: // NodeList getElementsByTagName(in DOMString tagname);
1.54 paf 744: add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
745: // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
746: add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
1.2 parser 747:
1.16 parser 748: /// DOM2(?)
1.2 parser 749:
1.16 parser 750: // ^xdoc.getElementById[elementId]
751: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.1 parser 752:
1.16 parser 753: /// parser
754:
1.54 paf 755: // ^xdoc::create{qualifiedName}
756: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);
757: // ^xdoc::set[<some>xml</some>]
758: add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
759:
760: // ^xdoc::load[some.xml]
761: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
762:
1.2 parser 763: // ^xdoc.save[some.xml]
764: // ^xdoc.save[some.xml;options hash]
1.1 parser 765: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
766:
1.2 parser 767: // ^xdoc.string[] <doc/>
768: // ^xdoc.string[options hash] <doc/>
1.1 parser 769: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
770:
1.2 parser 771: // ^xdoc.file[] file with "<doc/>"
772: // ^xdoc.file[options hash] file with "<doc/>"
1.54 paf 773: // add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
1.1 parser 774:
1.8 parser 775: // ^xdoc.transform[stylesheet file_name]
776: // ^xdoc.transform[stylesheet file_name;params hash]
1.54 paf 777: // add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 778:
1.1 parser 779: }
1.5 parser 780:
781: void MXdoc::configure_admin(Request& r) {
782: }
783:
1.1 parser 784: // global variable
785:
786: Methoded *Xdoc_class;
787:
788: // creator
789:
790: #endif
791:
792: Methoded *MXdoc_create(Pool& pool) {
793: return
794: #ifdef XML
1.33 parser 795: Xdoc_class=new(pool) MXdoc(pool)
1.1 parser 796: #else
797: 0
798: #endif
799: ;
800: }
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