Annotation of parser3/src/classes/xdoc.C, revision 1.55
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.55 ! paf 7: $Id: xdoc.C,v 1.54 2001/12/28 14:06:50 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.54 paf 309: static void _set(Request& r, const String& method_name, MethodParams *params) {
310: // _asm int 3;
311: Pool& pool=r.pool();
312: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.9 parser 313:
1.54 paf 314: Value& vxml=params->as_junction(0, "xml must be code");
315: Temp_lang temp_lang(r, String::UL_XML);
316: const String& xml=r.process(vxml).as_string();
1.9 parser 317:
1.54 paf 318: GdomeException exc;
319: GdomeDocument *document=gdome_di_createDocFromMemory(domimpl,
320: xml.cstr(String::UL_UNSPECIFIED, r.connection),
1.55 ! paf 321: GDOME_LOAD_PARSING
! 322: /* GDOME_LOAD_VALIDATING */
1.54 paf 323: /*|GDOME_LOAD_SUBSTITUTE_ENTITIES */,
324: &exc);
325: if(!document || exc)
326: throw Exception(0, 0,
327: &method_name,
328: exc);
1.9 parser 329:
1.54 paf 330: // replace any previous parsed source
331: vdoc.set_document(document);
1.9 parser 332: }
333:
1.54 paf 334: static void _load(Request& r, const String& method_name, MethodParams *params) {
335: Pool& pool=r.pool();
336: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.9 parser 337:
1.54 paf 338: // filespec
339: const String& file_name=params->as_string(0, "uri must be string");
340: const String& uri=r.absolute(file_name);
341:
342: GdomeException exc;
343: GdomeDocument *document=gdome_di_createDocFromURI(domimpl,
344: uri.cstr(),
1.55 ! paf 345: GDOME_LOAD_PARSING
! 346: /*GDOME_LOAD_VALIDATING */
1.54 paf 347: /*|GDOME_LOAD_SUBSTITUTE_ENTITIES */,
348: &exc);
349: if(!document || exc)
350: throw Exception(0, 0,
351: &method_name,
352: exc);
1.9 parser 353:
1.54 paf 354: // replace any previous parsed source
355: vdoc.set_document(document);
1.9 parser 356: }
357:
1.54 paf 358: /*
1.46 paf 359: static void param_option_over_output_option(Pool& pool,
360: Hash *param_options, const char *option_name,
361: XalanDOMString& output_option) {
362: if(Value *value=static_cast<Value *>(param_options->get(*new(pool)
363: String(pool, option_name)))) {
364: output_option.clear();
365: output_option.append(value->as_string().cstr());
366: }
367: }
368: static void param_option_over_output_option(Pool& pool,
369: Hash *param_options, const char *option_name,
370: bool& output_option) {
371: if(Value *value=static_cast<Value *>(param_options->get(*new(pool)
372: String(pool, option_name)))) {
373: const String& s=value->as_string();
374: if(s=="yes")
375: output_option=true;
376: else if(s=="no")
377: output_option=false;
378: else
379: throw Exception(0, 0,
380: &s,
381: "%s must be either 'yes' or 'no'", option_name);
382: }
383: }
384:
1.54 paf 385: static std::auto_ptr<FormatterListener> create_optioned_listener(
1.46 paf 386: Pool& pool, const String& method_name, MethodParams *params, int index,
1.52 paf 387: VXdoc::Output_options& oo, Writer& writer) {
1.46 paf 388: /*
389: XalanDOMString encoding;
390: XalanDOMString mediaType;
391: XalanDOMString doctypeSystem;
392: XalanDOMString doctypePublic;
393: bool doIndent;
394: XalanDOMString version;
395: XalanDOMString standalone;
396: bool xmlDecl;
1.54 paf 397: * /
1.9 parser 398:
1.46 paf 399: /*
400: <xsl:output
401: !method = "xml" | "html" | "text" | qname-but-not-ncname
402: !version = nmtoken
403: !encoding = string
404: !omit-xml-declaration = "yes" | "no"
405: !standalone = "yes" | "no"
406: !doctype-public = string
407: !doctype-system = string
408: cdata-section-elements = qnames
409: !indent = "yes" | "no"
410: !media-type = string />
1.54 paf 411: * /
1.9 parser 412:
1.46 paf 413: /*
414: fToXML->setStripCData(stripCData);
415: fToXML->setEscapeCData(escapeCData);
1.54 paf 416: * /
1.1 parser 417:
1.46 paf 418: // configuring with options from parameter...
1.1 parser 419: if(params->size()>index) {
1.20 parser 420: Value& voptions=params->as_no_junction(index, "options must be string");
1.1 parser 421: if(voptions.is_defined()) {
1.34 parser 422: if(Hash *options=voptions.get_hash(&method_name)) {
1.1 parser 423: // $.method[xml|html|text]
424: if(Value *vmethod=static_cast<Value *>(options->get(*new(pool)
425: String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
1.46 paf 426: oo.method=vmethod->as_string().cstr();
1.1 parser 427:
1.46 paf 428: // $.version[1.0]
429: param_option_over_output_option(pool, options, "version", oo.version);
1.1 parser 430: // $.encoding[windows-1251|...]
1.46 paf 431: param_option_over_output_option(pool, options, "encoding", oo.encoding);
432: // $.omit-xml-declaration[yes|no]
433: bool omit_xml_declaration=!oo.xmlDecl;
434: param_option_over_output_option(pool, options, "omit-xml-declaration", omit_xml_declaration);
435: oo.xmlDecl=!omit_xml_declaration;
436: // $.standalone[yes|no]
437: param_option_over_output_option(pool, options, "standalone", oo.standalone);
438: // $.doctype-public[?]
439: param_option_over_output_option(pool, options, "doctype-public", oo.doctypePublic);
440: // $.doctype-system[?]
441: param_option_over_output_option(pool, options, "doctype-system", oo.doctypeSystem);
442: // $.indent[yes|no]
443: param_option_over_output_option(pool, options, "indent", oo.doIndent);
444: // $.media-type[text/{html|xml|plain}]
445: param_option_over_output_option(pool, options, "media-type", oo.mediaType);
1.19 parser 446: }
1.1 parser 447: }
448: }
449:
1.46 paf 450: // default encoding from pool
451: if(oo.encoding.empty())
1.53 paf 452: oo.encoding.append(pool.get_source_charset().name().cstr());
1.46 paf 453: // default method=xml
454: if(!oo.method)
455: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML;
456:
457: if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)==0) {
458: if(oo.mediaType.empty())
459: oo.mediaType.append("text/xml");
1.52 paf 460: return std::auto_ptr<FormatterListener>(new FormatterToXML(writer,
1.46 paf 461: oo.version,
462: oo.doIndent,
1.1 parser 463: XDOC_OUTPUT_DEFAULT_INDENT, // indent
1.46 paf 464: oo.encoding,
465: oo.mediaType,
466: oo.doctypeSystem,
467: oo.doctypePublic,
468: oo.xmlDecl,
469: oo.standalone
1.49 paf 470: ));
1.46 paf 471: } else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)==0) {
472: if(oo.mediaType.empty())
473: oo.mediaType.append("text/html");
1.52 paf 474: return std::auto_ptr<FormatterListener>(new FormatterToHTML(writer,
1.46 paf 475: oo.encoding,
476: oo.mediaType,
477: oo.doctypeSystem,
478: oo.doctypePublic,
479: oo.doIndent,
480: XDOC_OUTPUT_DEFAULT_INDENT, // indent
481: oo.version,
482: oo.standalone,
483: oo.xmlDecl
1.49 paf 484: ));
1.46 paf 485: } else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT)==0) {
486: if(oo.mediaType.empty())
487: oo.mediaType.append("text/plain");
1.52 paf 488: return std::auto_ptr<FormatterListener>(new FormatterToText(writer,
1.46 paf 489: oo.encoding
1.49 paf 490: ));
1.1 parser 491: } else
1.29 parser 492: throw Exception(0, 0,
1.46 paf 493: &method_name,
1.1 parser 494: XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
495: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
496: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "
497: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "'");
1.52 paf 498:
499: // never reached
1.1 parser 500: }
1.54 paf 501: */
1.1 parser 502:
503: static void _save(Request& r, const String& method_name, MethodParams *params) {
504: Pool& pool=r.pool();
1.46 paf 505: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 506:
1.20 parser 507: const String& file_name=params->as_string(0, "file name must be string");
1.54 paf 508: const String& filespec=r.absolute(file_name);
1.1 parser 509:
1.54 paf 510: GdomeException exc;
511: if(!gdome_di_saveDocToFile(domimpl,
512: vdoc.get_document(&method_name),
513: filespec.cstr(String::UL_FILE_SPEC),
514: GDOME_SAVE_LIBXML_INDENT /*GDOME_SAVE_STANDARD */,
515: &exc))
516: throw Exception(0, 0,
517: &method_name,
518: exc);
1.1 parser 519: }
520:
521: static void _string(Request& r, const String& method_name, MethodParams *params) {
522: Pool& pool=r.pool();
1.21 parser 523: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 524:
1.54 paf 525: char *mem;
526: GdomeException exc;
527: if(!gdome_di_saveDocToMemory(domimpl,
528: vdoc.get_document(&method_name),
529: &mem,
530: GDOME_SAVE_LIBXML_INDENT /*GDOME_SAVE_STANDARD */,
531: &exc))
532: throw Exception(0, 0,
533: &method_name,
534: exc);
535:
536: // move to pool memory
537: size_t size=strlen(mem);
538: char *buf=(char *)pool.malloc(size);
539: memcpy(buf, mem, size);
540: g_free(mem);
541: // write out result
542: r.write_no_lang(*new(pool) String(pool, buf, size));
1.1 parser 543: }
544:
1.54 paf 545: /*
1.1 parser 546: static void _file(Request& r, const String& method_name, MethodParams *params) {
547: Pool& pool=r.pool();
1.46 paf 548: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 549: VXnode& vnode=*static_cast<VXnode *>(r.self);
550:
551: // node
1.54 paf 552: GdomeNode *node=vnode.get_node(pool, &method_name);
1.1 parser 553:
554: try {
1.46 paf 555: VXdoc::Output_options oo(vdoc.output_options);
1.1 parser 556: String& parserString=*new(pool) String(pool);
557: ParserStringXalanOutputStream stream(parserString);
558: XalanOutputStreamPrintWriter writer(stream);
1.52 paf 559: std::auto_ptr<FormatterListener> formatterListener=
560: create_optioned_listener(pool, method_name, params, 0,
561: oo, writer);
1.1 parser 562: FormatterTreeWalker treeWalker(*formatterListener);
563: treeWalker.traverse(&node); // Walk that node and produce the XML...
564:
565: // write out result
566: VFile& vfile=*new(pool) VFile(pool);
567: const char *cstr=parserString.cstr();
1.46 paf 568: const String& scontent_type=pool.transcode(oo.mediaType);
1.1 parser 569: Value *vcontent_type;
1.46 paf 570: if(oo.encoding.empty())
571: vcontent_type=new(pool) VString(scontent_type);
572: else {
1.1 parser 573: VHash *vhcontent_type=new(pool) VHash(pool);
1.46 paf 574: vhcontent_type->hash(&method_name).put(*value_name, new(pool) VString(scontent_type));
575: const String& scharset=pool.transcode(oo.encoding);
576: vhcontent_type->hash(&method_name).put(*new(pool) String(pool, "charset"), new(pool) VString(scharset));
1.1 parser 577: vcontent_type=vhcontent_type;
1.46 paf 578: }
579:
1.54 paf 580: vfile.set(false/*tainted* /, cstr, strlen(cstr), 0/*file_name* /, vcontent_type);
1.1 parser 581: r.write_no_lang(vfile);
582: } catch(const XSLException& e) {
1.32 parser 583: Exception::provide_source(pool, &method_name, e);
1.1 parser 584: }
585: }
1.54 paf 586: */
587: /*
1.38 paf 588: /// @test lang=String::UL_UNSPECIFIED?
1.1 parser 589: static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,
590: void *info) {
1.13 parser 591: XalanTransformer2& transformer=*static_cast<XalanTransformer2 *>(info);
1.38 paf 592: const char *attribute_cstr=aattribute.cstr(String::UL_UNSPECIFIED);
593: const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr(String::UL_UNSPECIFIED);
1.1 parser 594:
595: transformer.setStylesheetParam(
596: XalanDOMString(attribute_cstr),
597: XalanDOMString(meaning_cstr));
598: }
1.24 parser 599: static void _transform(Request& r, const String& method_name, MethodParams *params) {
600: Pool& pool=r.pool();
601: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
602:
603: // params
604: if(params->size()>1) {
605: Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
606: if(vparams.is_defined())
1.34 parser 607: if(Hash *params=vparams.get_hash(&method_name))
1.24 parser 608: params->for_each(add_xslt_param, &vdoc.transformer());
609: else
1.29 parser 610: throw Exception(0, 0,
1.24 parser 611: &method_name,
612: "transform parameters parameter must be hash");
613: }
614:
615: // stylesheet
616: const String& stylesheet_file_name=params->as_string(0, "file name must be string");
617: const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
618: //_asm int 3;
1.32 parser 619: Stylesheet_connection& connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.24 parser 620:
621: // target
1.35 paf 622: XalanDocument* target=vdoc.parser_xerces_liaison().createDocument();
1.24 parser 623:
624: // transform
625: try {
1.36 paf 626: // note:
627: // actually, never found any difference between the two
628: // but still there some extra "xerces" words at start of transform body
629: // wich were originally "xalan"
630: // not daring to change that
1.46 paf 631:
1.54 paf 632: const XalanCompiledStylesheet& stylesheet=connection.stylesheet(false/*nocache* /);
1.35 paf 633: if(vdoc.has_parsed_source()) { // set|load, not create?
634: vdoc.transformer().transform2(
635: vdoc.get_parsed_source(pool, &method_name),
1.46 paf 636: &stylesheet,
1.35 paf 637: target);
638: } else {
639: target=vdoc.parser_xerces_liaison().createDocument();
640: vdoc.transformer().transform2(
1.54 paf 641: vdoc.get_document(&method_name),
1.46 paf 642: &stylesheet,
1.35 paf 643: target);
644: }
1.54 paf 645: VXdoc& result=*new(pool) VXdoc(pool, target, false/*owns not* /);
1.46 paf 646: // write out result
647: r.write_no_lang(result);
648: //
649: if(const StylesheetRoot *stylesheetRoot=stylesheet.getStylesheetRoot()) {
650: /*
651: <xsl:output
652: !method = "xml" | "html" | "text"
653: X| qname-but-not-ncname
654: !version = nmtoken
655: !encoding = string
656: !omit-xml-declaration = "yes" | "no"
657: !standalone = "yes" | "no"
658: !doctype-public = string
659: !doctype-system = string
660: cdata-section-elements = qnames
661: !indent = "yes" | "no"
662: !media-type = string />
1.54 paf 663: * /
1.46 paf 664:
665: VXdoc::Output_options& oo=result.output_options;
666: oo.encoding=stylesheetRoot->m_encoding;
667: oo.mediaType=stylesheetRoot->m_mediatype;
668: oo.doctypeSystem=stylesheetRoot->m_doctypeSystem;
669: oo.doctypePublic=stylesheetRoot->m_doctypePublic;
670: oo.doIndent=stylesheetRoot->m_indentResult;
671: oo.version=stylesheetRoot->m_version;
672: oo.standalone=stylesheetRoot->m_standalone;
673: oo.xmlDecl=!stylesheetRoot->m_omitxmlDecl;
674:
675: switch(stylesheetRoot->getOutputMethod()) {
676: case FormatterListener::OUTPUT_METHOD_HTML:
677: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML; break;
678: case FormatterListener::OUTPUT_METHOD_TEXT:
679: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT; break;
680: case FormatterListener::OUTPUT_METHOD_NONE:
681: case FormatterListener::OUTPUT_METHOD_XML:
682: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML; break;
683: default:
684: throw Exception(0, 0,
685: &method_name,
686: "unsupported output method specified");
687: break; // never
688: }
689: }
1.13 parser 690: }
691: catch (XSLException& e) {
692: connection.close();
1.32 parser 693: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 694: }
695: catch (SAXParseException& e) {
696: connection.close();
1.32 parser 697: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 698: }
699: catch (SAXException& e) {
700: connection.close();
1.32 parser 701: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 702: }
703: catch (XMLException& e) {
704: connection.close();
1.32 parser 705: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 706: }
1.16 parser 707: catch(const XalanDOMException& e) {
1.13 parser 708: connection.close();
1.32 parser 709: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 710: }
1.42 paf 711:
712: // close
713: connection.close();
1.1 parser 714: }
1.54 paf 715: */
1.1 parser 716:
1.16 parser 717: // constructor
1.2 parser 718:
1.16 parser 719: MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
720: set_name(*NEW String(pool(), XDOC_CLASS_NAME));
1.2 parser 721:
1.16 parser 722: /// @test how to create empty type html?
1.2 parser 723:
1.16 parser 724: /// DOM1
1.2 parser 725:
1.16 parser 726: // Element createElement(in DOMString tagName) raises(DOMException);
727: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
728: // DocumentFragment createDocumentFragment();
729: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
730: // Text createTextNode(in DOMString data);
731: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
732: // Comment createComment(in DOMString data);
733: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
734: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
735: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
736: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
737: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
738: // Attr createAttribute(in DOMString name) raises(DOMException);
739: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
740: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
741: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
742: // NodeList getElementsByTagName(in DOMString tagname);
1.54 paf 743: add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
744: // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
745: add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
1.2 parser 746:
1.16 parser 747: /// DOM2(?)
1.2 parser 748:
1.16 parser 749: // ^xdoc.getElementById[elementId]
750: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.1 parser 751:
1.16 parser 752: /// parser
753:
1.54 paf 754: // ^xdoc::create{qualifiedName}
755: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);
756: // ^xdoc::set[<some>xml</some>]
757: add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
758:
759: // ^xdoc::load[some.xml]
760: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
761:
1.2 parser 762: // ^xdoc.save[some.xml]
763: // ^xdoc.save[some.xml;options hash]
1.1 parser 764: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
765:
1.2 parser 766: // ^xdoc.string[] <doc/>
767: // ^xdoc.string[options hash] <doc/>
1.1 parser 768: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
769:
1.2 parser 770: // ^xdoc.file[] file with "<doc/>"
771: // ^xdoc.file[options hash] file with "<doc/>"
1.54 paf 772: // add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
1.1 parser 773:
1.8 parser 774: // ^xdoc.transform[stylesheet file_name]
775: // ^xdoc.transform[stylesheet file_name;params hash]
1.54 paf 776: // add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 777:
1.1 parser 778: }
1.5 parser 779:
780: void MXdoc::configure_admin(Request& r) {
781: }
782:
1.1 parser 783: // global variable
784:
785: Methoded *Xdoc_class;
786:
787: // creator
788:
789: #endif
790:
791: Methoded *MXdoc_create(Pool& pool) {
792: return
793: #ifdef XML
1.33 parser 794: Xdoc_class=new(pool) MXdoc(pool)
1.1 parser 795: #else
796: 0
797: #endif
798: ;
799: }
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