Annotation of parser3/src/classes/xdoc.C, revision 1.51
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.51 ! paf 7: $Id: xdoc.C,v 1.50 2001/12/13 13:05:10 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.32 parser 15: #include "pa_stylesheet_manager.h"
1.1 parser 16: #include "pa_stylesheet_connection.h"
17: #include "pa_vfile.h"
18: #include "xnode.h"
19:
20: #include <strstream>
21: #include <Include/PlatformDefinitions.hpp>
22: #include <util/PlatformUtils.hpp>
1.5 parser 23: #include <util/TransENameMap.hpp>
1.13 parser 24: #include "XalanTransformer2.hpp"
1.1 parser 25: #include <XalanTransformer/XalanParsedSource.hpp>
1.9 parser 26: # include <XalanTransformer/XalanDefaultParsedSource.hpp>
27: # include <XalanSourceTree/XalanSourceTreeDocument.hpp>
1.10 parser 28: # include <XalanSourceTree/XalanSourceTreeContentHandler.hpp>
29: # include <sax2/XMLReaderFactory.hpp>
1.1 parser 30: #include <XMLSupport/FormatterToXML.hpp>
31: #include <XMLSupport/FormatterToHTML.hpp>
32: #include <XMLSupport/FormatterToText.hpp>
33: #include <XMLSupport/FormatterTreeWalker.hpp>
34: #include <PlatformSupport/XalanFileOutputStream.hpp>
35: #include <PlatformSupport/XalanOutputStreamPrintWriter.hpp>
36: #include <PlatformSupport/DOMStringPrintWriter.hpp>
1.2 parser 37: #include <XalanDOM/XalanElement.hpp>
38: #include <XalanDOM/XalanNodeList.hpp>
1.16 parser 39: #include <XalanDOM/XalanDocumentFragment.hpp>
40: #include <XalanDOM/XalanCDATASection.hpp>
41: #include <XalanDOM/XalanEntityReference.hpp>
1.30 parser 42: #include <dom/DOM_Document.hpp>
1.21 parser 43: #include <XercesParserLiaison/XercesDocumentBridge.hpp>
44: #include <XalanTransformer/XercesDOMParsedSource.hpp>
1.46 paf 45: #include <XSLT/StylesheetRoot.hpp>
46: #include <XalanTransformer/XalanCompiledStylesheet.hpp>
1.1 parser 47:
48: // defines
49:
50: #define XDOC_CLASS_NAME "xdoc"
51:
52: #define XDOC_OUTPUT_METHOD_OPTION_NAME "method"
53: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"
54: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"
55: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"
56: #define XDOC_OUTPUT_DEFAULT_INDENT 4
57:
58: // class
59:
60: class MXdoc : public MXnode {
61: public: // VStateless_class
1.28 parser 62: Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool, 0, false); }
1.1 parser 63:
64: public:
65: MXdoc(Pool& pool);
66:
67: public: // Methoded
68: bool used_directly() { return true; }
1.5 parser 69: void configure_admin(Request& r);
1.1 parser 70: };
71:
72: // methods
73:
1.16 parser 74: // Element createElement(in DOMString tagName) raises(DOMException);
75: static void _createElement(Request& r, const String& method_name, MethodParams *params) {
76: Pool& pool=r.pool();
77: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
78:
1.39 paf 79: const String& tagName=params->as_string(0, "tagName must be string");
1.16 parser 80:
81: try {
82: XalanNode *node=
83: vdoc.get_document(pool, &method_name).
1.30 parser 84: createElement(*pool.transcode(tagName));
1.16 parser 85: // write out result
1.31 parser 86: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 87: r.write_no_lang(result);
88: } catch(const XalanDOMException& e) {
1.32 parser 89: Exception::provide_source(pool, &method_name, e);
1.16 parser 90: }
91: }
92:
93: // DocumentFragment createDocumentFragment()
1.26 parser 94: static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {
1.16 parser 95: Pool& pool=r.pool();
96: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
97:
98: XalanNode *node=
99: vdoc.get_document(pool, &method_name).
100: createDocumentFragment();
101: // write out result
1.31 parser 102: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 103: r.write_no_lang(result);
104: }
105:
106: // Text createTextNode(in DOMString data);
107: static void _createTextNode(Request& r, const String& method_name, MethodParams *params) {
108: Pool& pool=r.pool();
109: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
110:
1.40 paf 111: const String& data=params->as_string(0, "data must be string");
1.16 parser 112:
113: XalanNode *node=
114: vdoc.get_document(pool, &method_name).
1.30 parser 115: createTextNode(*pool.transcode(data));
1.16 parser 116: // write out result
1.31 parser 117: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 118: r.write_no_lang(result);
119: }
120:
121: // Comment createComment(in DOMString data)
122: static void _createComment(Request& r, const String& method_name, MethodParams *params) {
123: Pool& pool=r.pool();
124: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
125:
1.26 parser 126: const String& data=params->as_string(0, "data must be string");
1.16 parser 127:
128: XalanNode *node=
129: vdoc.get_document(pool, &method_name).
1.30 parser 130: createComment(*pool.transcode(data));
1.16 parser 131: // write out result
1.31 parser 132: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 133: r.write_no_lang(result);
134: }
135:
136: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
137: static void _createCDATASection(Request& r, const String& method_name, MethodParams *params) {
138: Pool& pool=r.pool();
139: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
140:
1.26 parser 141: const String& data=params->as_string(0, "data must be string");
1.16 parser 142:
143: try {
144: XalanNode *node=
145: vdoc.get_document(pool, &method_name).
1.30 parser 146: createCDATASection(*pool.transcode(data));
1.16 parser 147: // write out result
1.31 parser 148: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 149: r.write_no_lang(result);
150: } catch(const XalanDOMException& e) {
1.32 parser 151: Exception::provide_source(pool, &method_name, e);
1.16 parser 152: }
153: }
154:
155: // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
156: static void _createProcessingInstruction(Request& r, const String& method_name, MethodParams *params) {
157: Pool& pool=r.pool();
158: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
159:
1.26 parser 160: const String& target=params->as_string(0, "data must be string");
161: const String& data=params->as_string(1, "data must be string");
1.16 parser 162:
163: try {
164: XalanNode *node=
165: vdoc.get_document(pool, &method_name).
1.30 parser 166: createProcessingInstruction(*pool.transcode(target), *pool.transcode(data));
1.16 parser 167: // write out result
1.31 parser 168: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 169: r.write_no_lang(result);
170: } catch(const XalanDOMException& e) {
1.32 parser 171: Exception::provide_source(pool, &method_name, e);
1.16 parser 172: }
173: }
174:
175: // Attr createAttribute(in DOMString name) raises(DOMException);
176: static void _createAttribute(Request& r, const String& method_name, MethodParams *params) {
177: Pool& pool=r.pool();
178: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
179:
1.26 parser 180: const String& name=params->as_string(0, "name must be string");
1.16 parser 181:
182: try {
183: XalanNode *node=
184: vdoc.get_document(pool, &method_name).
1.30 parser 185: createAttribute(*pool.transcode(name));
1.16 parser 186: // write out result
1.31 parser 187: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 188: r.write_no_lang(result);
189: } catch(const XalanDOMException& e) {
1.32 parser 190: Exception::provide_source(pool, &method_name, e);
1.16 parser 191: }
192: }
193: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
194: static void _createEntityReference(Request& r, const String& method_name, MethodParams *params) {
195: Pool& pool=r.pool();
196: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
197:
1.26 parser 198: const String& name=params->as_string(0, "name must be string");
1.16 parser 199:
200: try {
201: XalanNode *node=
202: vdoc.get_document(pool, &method_name).
1.30 parser 203: createEntityReference(*pool.transcode(name));
1.16 parser 204: // write out result
1.31 parser 205: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 206: r.write_no_lang(result);
207: } catch(const XalanDOMException& e) {
1.32 parser 208: Exception::provide_source(pool, &method_name, e);
1.16 parser 209: }
210: }
211:
212: /*
213: static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {
214: Pool& pool=r.pool();
215: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
216:
217: // tagname
1.20 parser 218: const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);
1.16 parser 219:
220: VHash& result=*new(pool) VHash(pool);
221: if(const XalanNodeList *nodes=
222: vdoc.get_document(pool, &method_name).getElementsByTagName(XalanDOMString(name))) {
223: for(int i=0; i<nodes->getLength(); i++) {
224: String& skey=*new(pool) String(pool);
225: {
226: char *buf=(char *)pool.malloc(MAX_NUMBER);
227: snprintf(buf, MAX_NUMBER, "%d", i);
228: skey << buf;
229: }
230:
231: result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));
232: }
233: }
234:
235: // write out result
236: r.write_no_lang(result);
237: }
238:
239: static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams *params) {
240: Pool& pool=r.pool();
241: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
242:
243: // namespaceURI;localName
1.20 parser 244: const char *namespaceURI=params->as_string(0, "namespaceURI must be string").cstr(String::UL_XML);
245: const char *localName=params->as_string(0, "localName must be string").cstr(String::UL_XML);
1.16 parser 246:
247: VHash& result=*new(pool) VHash(pool);
248: if(const XalanNodeList *nodes=
249: vdoc.get_document(pool, &method_name).getElementsByTagNameNS(
250: XalanDOMString(namespaceURI), XalanDOMString(localName))) {
251: for(int i=0; i<nodes->getLength(); i++) {
252: String& skey=*new(pool) String(pool);
253: {
254: char *buf=(char *)pool.malloc(MAX_NUMBER);
255: snprintf(buf, MAX_NUMBER, "%d", i);
256: skey << buf;
257: }
258:
259: result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));
260: }
261: }
262:
263: // write out result
264: r.write_no_lang(result);
265: }
266: */
267:
268:
1.1 parser 269: class ParserStringXalanOutputStream: public XalanOutputStream {
270: public:
271:
272: explicit ParserStringXalanOutputStream(String& astring) : fstring(astring) {}
273:
274: protected: // XalanOutputStream
275:
276: virtual void writeData(const char *theBuffer, unsigned long theBufferLength) {
277: char *copy=(char *)fstring.malloc((size_t)theBufferLength);
278: memcpy(copy, theBuffer, (size_t)theBufferLength);
1.2 parser 279: fstring.APPEND_CLEAN(copy, (size_t)theBufferLength, "xdoc", 0);
1.1 parser 280: }
281:
282: virtual void doFlush() {}
283:
284: private:
285:
286: String& fstring;
287:
288: };
289:
1.9 parser 290: class XalanSourceTreeParserLiaison2: public XalanSourceTreeParserLiaison {
291: public:
1.16 parser 292: XalanSourceTreeParserLiaison2(XalanSourceTreeDOMSupport& theSupport) : XalanSourceTreeParserLiaison(theSupport),
1.9 parser 293: ferror_handler(new HandlerBase) {
294: }
295:
1.10 parser 296: XalanDocument*
297: parseXMLStream2(
1.16 parser 298: const InputSource& inputSource) {
1.10 parser 299: XalanSourceTreeContentHandler theContentHandler(createXalanSourceTreeDocument());
300: XalanAutoPtr<SAX2XMLReader> theReader(XMLReaderFactory::createXMLReader());
301: theReader->setContentHandler(&theContentHandler);
302: theReader->setDTDHandler(&theContentHandler);
303: theReader->setErrorHandler(ferror_handler); // disable stderr output
304: theReader->setLexicalHandler(&theContentHandler);
305: EntityResolver* const theResolver = getEntityResolver();
306: if (theResolver != 0) {
307: theReader->setEntityResolver(theResolver);
308: }
309: theReader->parse(inputSource);
310: return theContentHandler.getDocument();
311: }
312:
1.9 parser 313: ~XalanSourceTreeParserLiaison2() {
1.11 parser 314: delete ferror_handler;
1.9 parser 315: }
316: private:
317: ErrorHandler *ferror_handler;
318: };
319:
320: class XalanDefaultParsedSource2 : public XalanParsedSource
321: {
322: public:
323:
1.16 parser 324: XalanDefaultParsedSource2(const XSLTInputSource& theInputSource);
1.9 parser 325:
326: virtual XalanDocument*
327: getDocument() const;
328:
329: virtual XalanParsedSourceHelper*
330: createHelper() const;
331:
332: private:
333:
334: XalanSourceTreeDOMSupport m_domSupport;
335:
1.10 parser 336: XalanSourceTreeParserLiaison2 m_parserLiaison2;
1.9 parser 337:
338: XalanSourceTreeDocument* const m_parsedSource;
339: };
340:
1.16 parser 341: XalanDefaultParsedSource2::XalanDefaultParsedSource2(const XSLTInputSource& theInputSource):
1.9 parser 342: XalanParsedSource(),
343: m_domSupport(),
1.10 parser 344: m_parserLiaison2(m_domSupport),
345: m_parsedSource(m_parserLiaison2.mapDocument(m_parserLiaison2.parseXMLStream2(theInputSource)))
1.9 parser 346: {
347: assert(m_parsedSource != 0);
348:
1.10 parser 349: m_domSupport.setParserLiaison(&m_parserLiaison2);
1.9 parser 350: }
351:
352:
353:
354: XalanDocument*
355: XalanDefaultParsedSource2::getDocument() const
356: {
357: return m_parsedSource;
358: }
359:
360:
361:
362: XalanParsedSourceHelper*
363: XalanDefaultParsedSource2::createHelper() const
364: {
365: return new XalanDefaultParsedSourceHelper(m_domSupport);
366: }
367:
368:
1.46 paf 369: static void param_option_over_output_option(Pool& pool,
370: Hash *param_options, const char *option_name,
371: XalanDOMString& output_option) {
372: if(Value *value=static_cast<Value *>(param_options->get(*new(pool)
373: String(pool, option_name)))) {
374: output_option.clear();
375: output_option.append(value->as_string().cstr());
376: }
377: }
378: static void param_option_over_output_option(Pool& pool,
379: Hash *param_options, const char *option_name,
380: bool& output_option) {
381: if(Value *value=static_cast<Value *>(param_options->get(*new(pool)
382: String(pool, option_name)))) {
383: const String& s=value->as_string();
384: if(s=="yes")
385: output_option=true;
386: else if(s=="no")
387: output_option=false;
388: else
389: throw Exception(0, 0,
390: &s,
391: "%s must be either 'yes' or 'no'", option_name);
392: }
393: }
394:
395: static void create_optioned_listener(
396: Pool& pool, const String& method_name, MethodParams *params, int index,
397: VXdoc::Output_options& oo, Writer& writer,
1.51 ! paf 398: std::auto_ptr<FormatterListener> *listener) {
1.46 paf 399: /*
400: XalanDOMString encoding;
401: XalanDOMString mediaType;
402: XalanDOMString doctypeSystem;
403: XalanDOMString doctypePublic;
404: bool doIndent;
405: XalanDOMString version;
406: XalanDOMString standalone;
407: bool xmlDecl;
408: */
1.9 parser 409:
1.46 paf 410: /*
411: <xsl:output
412: !method = "xml" | "html" | "text" | qname-but-not-ncname
413: !version = nmtoken
414: !encoding = string
415: !omit-xml-declaration = "yes" | "no"
416: !standalone = "yes" | "no"
417: !doctype-public = string
418: !doctype-system = string
419: cdata-section-elements = qnames
420: !indent = "yes" | "no"
421: !media-type = string />
422: */
1.9 parser 423:
1.46 paf 424: /*
425: fToXML->setStripCData(stripCData);
426: fToXML->setEscapeCData(escapeCData);
427: */
1.1 parser 428:
1.46 paf 429: // configuring with options from parameter...
1.1 parser 430: if(params->size()>index) {
1.20 parser 431: Value& voptions=params->as_no_junction(index, "options must be string");
1.1 parser 432: if(voptions.is_defined()) {
1.34 parser 433: if(Hash *options=voptions.get_hash(&method_name)) {
1.1 parser 434: // $.method[xml|html|text]
435: if(Value *vmethod=static_cast<Value *>(options->get(*new(pool)
436: String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
1.46 paf 437: oo.method=vmethod->as_string().cstr();
1.1 parser 438:
1.46 paf 439: // $.version[1.0]
440: param_option_over_output_option(pool, options, "version", oo.version);
1.1 parser 441: // $.encoding[windows-1251|...]
1.46 paf 442: param_option_over_output_option(pool, options, "encoding", oo.encoding);
443: // $.omit-xml-declaration[yes|no]
444: bool omit_xml_declaration=!oo.xmlDecl;
445: param_option_over_output_option(pool, options, "omit-xml-declaration", omit_xml_declaration);
446: oo.xmlDecl=!omit_xml_declaration;
447: // $.standalone[yes|no]
448: param_option_over_output_option(pool, options, "standalone", oo.standalone);
449: // $.doctype-public[?]
450: param_option_over_output_option(pool, options, "doctype-public", oo.doctypePublic);
451: // $.doctype-system[?]
452: param_option_over_output_option(pool, options, "doctype-system", oo.doctypeSystem);
453: // $.indent[yes|no]
454: param_option_over_output_option(pool, options, "indent", oo.doIndent);
455: // $.media-type[text/{html|xml|plain}]
456: param_option_over_output_option(pool, options, "media-type", oo.mediaType);
1.19 parser 457: }
1.1 parser 458: }
459: }
460:
1.46 paf 461: // default encoding from pool
462: if(oo.encoding.empty())
463: oo.encoding.append(pool.get_charset().cstr());
464: // default method=xml
465: if(!oo.method)
466: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML;
467:
468: if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)==0) {
469: if(oo.mediaType.empty())
470: oo.mediaType.append("text/xml");
1.51 ! paf 471: *listener=std::auto_ptr<FormatterListener>(new FormatterToXML(writer,
1.46 paf 472: oo.version,
473: oo.doIndent,
1.1 parser 474: XDOC_OUTPUT_DEFAULT_INDENT, // indent
1.46 paf 475: oo.encoding,
476: oo.mediaType,
477: oo.doctypeSystem,
478: oo.doctypePublic,
479: oo.xmlDecl,
480: oo.standalone
1.49 paf 481: ));
1.46 paf 482: } else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)==0) {
483: if(oo.mediaType.empty())
484: oo.mediaType.append("text/html");
1.51 ! paf 485: *listener=std::auto_ptr<FormatterListener>(new FormatterToHTML(writer,
1.46 paf 486: oo.encoding,
487: oo.mediaType,
488: oo.doctypeSystem,
489: oo.doctypePublic,
490: oo.doIndent,
491: XDOC_OUTPUT_DEFAULT_INDENT, // indent
492: oo.version,
493: oo.standalone,
494: oo.xmlDecl
1.49 paf 495: ));
1.46 paf 496: } else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT)==0) {
497: if(oo.mediaType.empty())
498: oo.mediaType.append("text/plain");
1.51 ! paf 499: *listener=std::auto_ptr<FormatterListener>(new FormatterToText(writer,
1.46 paf 500: oo.encoding
1.49 paf 501: ));
1.1 parser 502: } else
1.29 parser 503: throw Exception(0, 0,
1.46 paf 504: &method_name,
1.1 parser 505: XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
506: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
507: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "
508: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "'");
509: }
510:
511: static void _save(Request& r, const String& method_name, MethodParams *params) {
512: Pool& pool=r.pool();
1.46 paf 513: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 514: VXnode& vnode=*static_cast<VXnode *>(r.self);
515:
516: // filespec
1.20 parser 517: const String& file_name=params->as_string(0, "file name must be string");
1.1 parser 518: const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
519:
520: // node
521: XalanNode& node=vnode.get_node(pool, &method_name);
522:
523: try {
1.46 paf 524: VXdoc::Output_options oo(vdoc.output_options);
1.1 parser 525: XalanFileOutputStream stream(XalanDOMString(filespec, strlen(filespec)));
526: XalanOutputStreamPrintWriter writer(stream);
1.49 paf 527: std::auto_ptr<FormatterListener> formatterListener;
1.46 paf 528: create_optioned_listener(pool, method_name, params, 1,
1.51 ! paf 529: oo, writer, &formatterListener);
1.1 parser 530: FormatterTreeWalker treeWalker(*formatterListener);
531: treeWalker.traverse(&node); // Walk that node and produce the XML...
532: } catch(const XSLException& e) {
1.32 parser 533: Exception::provide_source(pool, &method_name, e);
1.1 parser 534: }
535: }
536:
537: static void _string(Request& r, const String& method_name, MethodParams *params) {
538: Pool& pool=r.pool();
1.21 parser 539: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 540:
541: // node
1.21 parser 542: XalanNode *node=&vdoc.get_document(pool, &method_name);//.getDocumentElement();
543: if(!node)
1.29 parser 544: throw Exception(0, 0,
1.21 parser 545: &method_name,
546: "no documentElement");
1.1 parser 547:
548: try {
1.46 paf 549: VXdoc::Output_options oo(vdoc.output_options);
1.49 paf 550: String& parserString=*new(pool) String(pool);
1.1 parser 551: ParserStringXalanOutputStream stream(parserString);
1.23 parser 552: XalanOutputStreamPrintWriter writer(stream);
1.49 paf 553: std::auto_ptr<FormatterListener> formatterListener;
1.46 paf 554: create_optioned_listener(pool, method_name, params, 0,
1.51 ! paf 555: oo, writer, &formatterListener);
1.23 parser 556: FormatterTreeWalker treeWalker(*formatterListener);
557: treeWalker.traverse(node); // Walk that node and produce the XML...
1.1 parser 558:
559: // write out result
560: r.write_no_lang(parserString);
561: } catch(const XSLException& e) {
1.32 parser 562: Exception::provide_source(pool, &method_name, e);
1.1 parser 563: }
564: }
565:
566:
567: static void _file(Request& r, const String& method_name, MethodParams *params) {
568: Pool& pool=r.pool();
1.46 paf 569: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 570: VXnode& vnode=*static_cast<VXnode *>(r.self);
571:
572: // node
573: XalanNode& node=vnode.get_node(pool, &method_name);
574:
575: try {
1.46 paf 576: VXdoc::Output_options oo(vdoc.output_options);
1.1 parser 577: String& parserString=*new(pool) String(pool);
578: ParserStringXalanOutputStream stream(parserString);
579: XalanOutputStreamPrintWriter writer(stream);
1.49 paf 580: std::auto_ptr<FormatterListener> formatterListener;
1.46 paf 581: create_optioned_listener(pool, method_name, params, 0,
1.51 ! paf 582: oo, writer, &formatterListener);
1.1 parser 583: FormatterTreeWalker treeWalker(*formatterListener);
584: treeWalker.traverse(&node); // Walk that node and produce the XML...
585:
586: // write out result
587: VFile& vfile=*new(pool) VFile(pool);
588: const char *cstr=parserString.cstr();
1.46 paf 589: const String& scontent_type=pool.transcode(oo.mediaType);
1.1 parser 590: Value *vcontent_type;
1.46 paf 591: if(oo.encoding.empty())
592: vcontent_type=new(pool) VString(scontent_type);
593: else {
1.1 parser 594: VHash *vhcontent_type=new(pool) VHash(pool);
1.46 paf 595: vhcontent_type->hash(&method_name).put(*value_name, new(pool) VString(scontent_type));
596: const String& scharset=pool.transcode(oo.encoding);
597: vhcontent_type->hash(&method_name).put(*new(pool) String(pool, "charset"), new(pool) VString(scharset));
1.1 parser 598: vcontent_type=vhcontent_type;
1.46 paf 599: }
600:
1.1 parser 601: vfile.set(false/*tainted*/, cstr, strlen(cstr), 0/*file_name*/, vcontent_type);
602: r.write_no_lang(vfile);
603: } catch(const XSLException& e) {
1.32 parser 604: Exception::provide_source(pool, &method_name, e);
1.1 parser 605: }
606: }
607:
608: static void _set(Request& r, const String& method_name, MethodParams *params) {
1.48 paf 609: // _asm int 3;
1.1 parser 610: Pool& pool=r.pool();
1.5 parser 611: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 612:
613: Value& vxml=params->as_junction(0, "xml must be code");
614: Temp_lang temp_lang(r, String::UL_XML);
615: const String& xml=r.process(vxml).as_string();
616:
1.44 paf 617: std::istrstream stream(
618: xml.cstr(String::UL_UNSPECIFIED, r.connection));
1.1 parser 619: const XalanParsedSource* parsedSource;
1.9 parser 620:
1.11 parser 621: try {
622: parsedSource = new XalanDefaultParsedSource2(&stream);
1.9 parser 623: }
1.10 parser 624: catch (XSLException& e) {
1.32 parser 625: Exception::provide_source(pool, &method_name, e);
1.10 parser 626: }
627: catch (SAXParseException& e) {
1.32 parser 628: Exception::provide_source(pool, &method_name, e);
1.9 parser 629: }
1.10 parser 630: catch (SAXException& e) {
1.32 parser 631: Exception::provide_source(pool, &method_name, e);
1.9 parser 632: }
1.10 parser 633: catch (XMLException& e) {
1.32 parser 634: Exception::provide_source(pool, &method_name, e);
1.9 parser 635: }
1.16 parser 636: catch(const XalanDOMException& e) {
1.32 parser 637: Exception::provide_source(pool, &method_name, e);
1.9 parser 638: }
1.1 parser 639:
640: // replace any previous parsed source
1.5 parser 641: vdoc.set_parsed_source(*parsedSource);
1.1 parser 642: }
643:
1.17 parser 644: static void _create(Request& r, const String& method_name, MethodParams *params) {
1.27 parser 645: //_asm int 3;
1.17 parser 646: Pool& pool=r.pool();
647: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
648:
1.26 parser 649: const String& qualifiedName=params->as_string(0, "qualifiedName must be string");
1.17 parser 650:
1.25 parser 651: XalanDocument& document=*new XercesDocumentBridge(
652: DOM_Document::createDocument(),
1.21 parser 653: 0,
654: false /*threadSafe*/,
1.22 parser 655: false /*don' buildBridge -- too early, empty document*/);
1.17 parser 656:
1.25 parser 657: /// +createXMLDecl ?
1.30 parser 658: document.appendChild(document.createElement(*pool.transcode(qualifiedName)));
1.25 parser 659:
1.21 parser 660: // replace any previous document
1.28 parser 661: vdoc.set_document(document, true/*owns*/);
1.17 parser 662: }
663:
1.1 parser 664: static void _load(Request& r, const String& method_name, MethodParams *params) {
665: Pool& pool=r.pool();
1.5 parser 666: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 667:
668: // filespec
1.20 parser 669: const String& file_name=params->as_string(0, "file name must be string");
1.1 parser 670: const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
671:
672: const XalanParsedSource* parsedSource;
1.12 parser 673: try {
674: parsedSource = new XalanDefaultParsedSource2(filespec);
675: }
676: catch (XSLException& e) {
1.32 parser 677: Exception::provide_source(pool, &method_name, e);
1.12 parser 678: }
679: catch (SAXParseException& e) {
1.32 parser 680: Exception::provide_source(pool, &method_name, e);
1.12 parser 681: }
682: catch (SAXException& e) {
1.32 parser 683: Exception::provide_source(pool, &method_name, e);
1.12 parser 684: }
685: catch (XMLException& e) {
1.32 parser 686: Exception::provide_source(pool, &method_name, e);
1.12 parser 687: }
1.16 parser 688: catch(const XalanDOMException& e) {
1.32 parser 689: Exception::provide_source(pool, &method_name, e);
1.12 parser 690: }
1.1 parser 691:
692: // replace any previous parsed source
1.5 parser 693: vdoc.set_parsed_source(*parsedSource);
1.1 parser 694: }
695:
1.38 paf 696: /// @test lang=String::UL_UNSPECIFIED?
1.1 parser 697: static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,
698: void *info) {
1.13 parser 699: XalanTransformer2& transformer=*static_cast<XalanTransformer2 *>(info);
1.38 paf 700: const char *attribute_cstr=aattribute.cstr(String::UL_UNSPECIFIED);
701: const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr(String::UL_UNSPECIFIED);
1.1 parser 702:
703: transformer.setStylesheetParam(
704: XalanDOMString(attribute_cstr),
705: XalanDOMString(meaning_cstr));
706: }
1.24 parser 707: static void _transform(Request& r, const String& method_name, MethodParams *params) {
708: Pool& pool=r.pool();
709: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
710:
711: // params
712: if(params->size()>1) {
713: Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
714: if(vparams.is_defined())
1.34 parser 715: if(Hash *params=vparams.get_hash(&method_name))
1.24 parser 716: params->for_each(add_xslt_param, &vdoc.transformer());
717: else
1.29 parser 718: throw Exception(0, 0,
1.24 parser 719: &method_name,
720: "transform parameters parameter must be hash");
721: }
722:
723: // stylesheet
724: const String& stylesheet_file_name=params->as_string(0, "file name must be string");
725: const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
726: //_asm int 3;
1.32 parser 727: Stylesheet_connection& connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.24 parser 728:
729: // target
1.35 paf 730: XalanDocument* target=vdoc.parser_xerces_liaison().createDocument();
1.24 parser 731:
732: // transform
733: try {
1.36 paf 734: // note:
735: // actually, never found any difference between the two
736: // but still there some extra "xerces" words at start of transform body
737: // wich were originally "xalan"
738: // not daring to change that
1.46 paf 739:
1.47 paf 740: const XalanCompiledStylesheet& stylesheet=connection.stylesheet(false/*nocache*/);
1.35 paf 741: if(vdoc.has_parsed_source()) { // set|load, not create?
742: vdoc.transformer().transform2(
743: vdoc.get_parsed_source(pool, &method_name),
1.46 paf 744: &stylesheet,
1.35 paf 745: target);
746: } else {
747: target=vdoc.parser_xerces_liaison().createDocument();
748: vdoc.transformer().transform2(
749: vdoc.get_document(pool, &method_name),
1.46 paf 750: &stylesheet,
1.35 paf 751: target);
752: }
1.46 paf 753: VXdoc& result=*new(pool) VXdoc(pool, target, false/*owns not*/);
754: // write out result
755: r.write_no_lang(result);
756: //
757: if(const StylesheetRoot *stylesheetRoot=stylesheet.getStylesheetRoot()) {
758: /*
759: <xsl:output
760: !method = "xml" | "html" | "text"
761: X| qname-but-not-ncname
762: !version = nmtoken
763: !encoding = string
764: !omit-xml-declaration = "yes" | "no"
765: !standalone = "yes" | "no"
766: !doctype-public = string
767: !doctype-system = string
768: cdata-section-elements = qnames
769: !indent = "yes" | "no"
770: !media-type = string />
771: */
772:
773: VXdoc::Output_options& oo=result.output_options;
774: oo.encoding=stylesheetRoot->m_encoding;
775: oo.mediaType=stylesheetRoot->m_mediatype;
776: oo.doctypeSystem=stylesheetRoot->m_doctypeSystem;
777: oo.doctypePublic=stylesheetRoot->m_doctypePublic;
778: oo.doIndent=stylesheetRoot->m_indentResult;
779: oo.version=stylesheetRoot->m_version;
780: oo.standalone=stylesheetRoot->m_standalone;
781: oo.xmlDecl=!stylesheetRoot->m_omitxmlDecl;
782:
783: switch(stylesheetRoot->getOutputMethod()) {
784: case FormatterListener::OUTPUT_METHOD_HTML:
785: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML; break;
786: case FormatterListener::OUTPUT_METHOD_TEXT:
787: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT; break;
788: case FormatterListener::OUTPUT_METHOD_NONE:
789: case FormatterListener::OUTPUT_METHOD_XML:
790: oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML; break;
791: default:
792: throw Exception(0, 0,
793: &method_name,
794: "unsupported output method specified");
795: break; // never
796: }
797: }
1.13 parser 798: }
799: catch (XSLException& e) {
800: connection.close();
1.32 parser 801: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 802: }
803: catch (SAXParseException& e) {
804: connection.close();
1.32 parser 805: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 806: }
807: catch (SAXException& e) {
808: connection.close();
1.32 parser 809: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 810: }
811: catch (XMLException& e) {
812: connection.close();
1.32 parser 813: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 814: }
1.16 parser 815: catch(const XalanDOMException& e) {
1.13 parser 816: connection.close();
1.32 parser 817: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 818: }
1.42 paf 819:
820: // close
821: connection.close();
1.1 parser 822: }
823:
1.2 parser 824: static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
825: Pool& pool=r.pool();
826: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
827:
828: // elementId
1.26 parser 829: const String& elementId=params->as_string(0, "elementID must be string");
1.2 parser 830:
1.16 parser 831: if(XalanNode *node=
1.30 parser 832: vdoc.get_document(pool, &method_name).getElementById(*pool.transcode(elementId))) {
1.2 parser 833: // write out result
1.31 parser 834: VXnode& result=*new(pool) VXnode(pool, node, false);
1.2 parser 835: r.write_no_lang(result);
836: }
837: }
1.16 parser 838: // constructor
1.2 parser 839:
1.16 parser 840: MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
841: set_name(*NEW String(pool(), XDOC_CLASS_NAME));
1.2 parser 842:
1.16 parser 843: /// @test how to create empty type html?
1.2 parser 844:
1.16 parser 845: /// DOM1
1.2 parser 846:
1.16 parser 847: // Element createElement(in DOMString tagName) raises(DOMException);
848: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
849: // DocumentFragment createDocumentFragment();
850: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
851: // Text createTextNode(in DOMString data);
852: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
853: // Comment createComment(in DOMString data);
854: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
855: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
856: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
857: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
858: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
859: // Attr createAttribute(in DOMString name) raises(DOMException);
860: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
861: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
862: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
863: // NodeList getElementsByTagName(in DOMString tagname);
864: /*
865: // ^xdoc.getElementsByTagName[tagname]
866: add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
867:
868: // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
869: add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
870: */
1.2 parser 871:
1.16 parser 872: /// DOM2(?)
1.2 parser 873:
1.16 parser 874: // ^xdoc.getElementById[elementId]
875: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.1 parser 876:
1.16 parser 877: /// parser
878:
1.2 parser 879: // ^xdoc.save[some.xml]
880: // ^xdoc.save[some.xml;options hash]
1.1 parser 881: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
882:
1.2 parser 883: // ^xdoc.string[] <doc/>
884: // ^xdoc.string[options hash] <doc/>
1.1 parser 885: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
886:
1.2 parser 887: // ^xdoc.file[] file with "<doc/>"
888: // ^xdoc.file[options hash] file with "<doc/>"
1.1 parser 889: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
890:
1.2 parser 891: // ^xdoc::set[<some>xml</some>]
1.1 parser 892: add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
1.18 parser 893: // ^xdoc::create{qualifiedName}
1.19 parser 894: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);
1.1 parser 895:
1.2 parser 896: // ^xdoc::load[some.xml]
1.1 parser 897: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
898:
1.8 parser 899: // ^xdoc.transform[stylesheet file_name]
900: // ^xdoc.transform[stylesheet file_name;params hash]
901: add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 902:
1.1 parser 903: }
1.5 parser 904:
905: void MXdoc::configure_admin(Request& r) {
906: }
907:
1.1 parser 908: // global variable
909:
910: Methoded *Xdoc_class;
911:
912: // creator
913:
914: #endif
915:
916: Methoded *MXdoc_create(Pool& pool) {
917: return
918: #ifdef XML
1.33 parser 919: Xdoc_class=new(pool) MXdoc(pool)
1.1 parser 920: #else
921: 0
922: #endif
923: ;
924: }
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