Annotation of parser3/src/classes/xdoc.C, revision 1.24
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)
5: Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
6:
1.24 ! parser 7: $Id: xdoc.C,v 1.23 2001/10/18 10:24:25 parser Exp $
1.1 parser 8: */
9: #include "classes.h"
10: #ifdef XML
11:
12: #include "pa_request.h"
13: #include "pa_vxdoc.h"
14: #include "pa_xslt_stylesheet_manager.h"
15: #include "pa_stylesheet_connection.h"
16: #include "pa_vfile.h"
17: #include "xnode.h"
18:
19: #include <strstream>
20: #include <Include/PlatformDefinitions.hpp>
21: #include <util/PlatformUtils.hpp>
1.5 parser 22: #include <util/TransENameMap.hpp>
1.13 parser 23: #include "XalanTransformer2.hpp"
1.1 parser 24: #include <XalanTransformer/XalanParsedSource.hpp>
1.9 parser 25: # include <XalanTransformer/XalanDefaultParsedSource.hpp>
26: # include <XalanSourceTree/XalanSourceTreeDocument.hpp>
1.10 parser 27: # include <XalanSourceTree/XalanSourceTreeContentHandler.hpp>
28: # include <sax2/XMLReaderFactory.hpp>
1.1 parser 29: #include <XMLSupport/FormatterToXML.hpp>
30: #include <XMLSupport/FormatterToHTML.hpp>
31: #include <XMLSupport/FormatterToText.hpp>
32: #include <XMLSupport/FormatterTreeWalker.hpp>
33: #include <PlatformSupport/XalanFileOutputStream.hpp>
34: #include <PlatformSupport/XalanOutputStreamPrintWriter.hpp>
35: #include <PlatformSupport/DOMStringPrintWriter.hpp>
1.2 parser 36: #include <XalanDOM/XalanElement.hpp>
37: #include <XalanDOM/XalanNodeList.hpp>
1.16 parser 38: #include <XalanDOM/XalanDocumentFragment.hpp>
39: #include <XalanDOM/XalanCDATASection.hpp>
40: #include <XalanDOM/XalanEntityReference.hpp>
1.21 parser 41: #include <DOM/DOM_Document.hpp>
42: #include <XercesParserLiaison/XercesDocumentBridge.hpp>
43: #include <XalanTransformer/XercesDOMParsedSource.hpp>
1.1 parser 44:
45: // defines
46:
47: #define XDOC_CLASS_NAME "xdoc"
48:
49: #define XDOC_OUTPUT_METHOD_OPTION_NAME "method"
50: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"
51: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"
52: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"
53:
54: #define XDOC_OUTPUT_ENCODING_OPTION_NAME "encoding"
55:
56: #define XDOC_OUTPUT_DEFAULT_INDENT 4
57:
58: // class
59:
60: class MXdoc : public MXnode {
61: public: // VStateless_class
62: Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool); }
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.20 parser 79: const char *tagName=params->as_string(0, "tagName must be string").cstr(String::UL_XML);
1.16 parser 80:
81: try {
82: XalanNode *node=
83: vdoc.get_document(pool, &method_name).
84: createElement(XalanDOMString(tagName));
85: // write out result
86: VXnode& result=*new(pool) VXnode(pool, node);
87: r.write_no_lang(result);
88: } catch(const XalanDOMException& e) {
89: pool.exception()._throw(pool, &method_name, e);
90: }
91: }
92:
93: // DocumentFragment createDocumentFragment()
94: static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *params) {
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
102: VXnode& result=*new(pool) VXnode(pool, node);
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.20 parser 111: const char *data=params->as_string(0, "data must be string").cstr(String::UL_XML);
1.16 parser 112:
113: XalanNode *node=
114: vdoc.get_document(pool, &method_name).
115: createTextNode(XalanDOMString(data));
116: // write out result
117: VXnode& result=*new(pool) VXnode(pool, node);
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.20 parser 126: const char *data=params->as_string(0, "data must be string").cstr(String::UL_XML);
1.16 parser 127:
128: XalanNode *node=
129: vdoc.get_document(pool, &method_name).
130: createComment(XalanDOMString(data));
131: // write out result
132: VXnode& result=*new(pool) VXnode(pool, node);
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.20 parser 141: const char *data=params->as_string(0, "data must be string").cstr(String::UL_XML);
1.16 parser 142:
143: try {
144: XalanNode *node=
145: vdoc.get_document(pool, &method_name).
146: createCDATASection(XalanDOMString(data));
147: // write out result
148: VXnode& result=*new(pool) VXnode(pool, node);
149: r.write_no_lang(result);
150: } catch(const XalanDOMException& e) {
151: pool.exception()._throw(pool, &method_name, e);
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.20 parser 160: const char *target=params->as_string(0, "target must be string").cstr(String::UL_XML);
161: const char *data=params->as_string(1, "data must be string").cstr(String::UL_XML);
1.16 parser 162:
163: try {
164: XalanNode *node=
165: vdoc.get_document(pool, &method_name).
166: createProcessingInstruction(XalanDOMString(target), XalanDOMString(data));
167: // write out result
168: VXnode& result=*new(pool) VXnode(pool, node);
169: r.write_no_lang(result);
170: } catch(const XalanDOMException& e) {
171: pool.exception()._throw(pool, &method_name, e);
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.20 parser 180: const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);
1.16 parser 181:
182: try {
183: XalanNode *node=
184: vdoc.get_document(pool, &method_name).
185: createAttribute(XalanDOMString(name));
186: // write out result
187: VXnode& result=*new(pool) VXnode(pool, node);
188: r.write_no_lang(result);
189: } catch(const XalanDOMException& e) {
190: pool.exception()._throw(pool, &method_name, e);
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.20 parser 198: const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);
1.16 parser 199:
200: try {
201: XalanNode *node=
202: vdoc.get_document(pool, &method_name).
203: createEntityReference(XalanDOMString(name));
204: // write out result
205: VXnode& result=*new(pool) VXnode(pool, node);
206: r.write_no_lang(result);
207: } catch(const XalanDOMException& e) {
208: pool.exception()._throw(pool, &method_name, e);
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:
369:
370:
1.1 parser 371: static void create_optioned_listener(
372: const char *& content_type, const char *& charset, FormatterListener *& listener,
373: Pool& pool,
374: const String& method_name, MethodParams *params, int index, Writer& writer) {
375: // default encoding from pool
376: const String *scharset=&pool.get_charset();
377: const String *method=0;
378: XalanDOMString xalan_encoding;
379:
380: if(params->size()>index) {
1.20 parser 381: Value& voptions=params->as_no_junction(index, "options must be string");
1.1 parser 382: if(voptions.is_defined()) {
383: if(Hash *options=voptions.get_hash()) {
384: // $.method[xml|html|text]
385: if(Value *vmethod=static_cast<Value *>(options->get(*new(pool)
386: String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
387: method=&vmethod->as_string();
388:
389: // $.encoding[windows-1251|...]
390: if(Value *vencoding=static_cast<Value *>(options->get(*new(pool)
391: String(pool, XDOC_OUTPUT_ENCODING_OPTION_NAME)))) {
392: scharset=&vencoding->as_string();
393: }
1.19 parser 394: }
1.1 parser 395: }
396: }
397:
398: xalan_encoding.append(charset=scharset->cstr());
399: if(!method/*default='xml'*/ || *method == XDOC_OUTPUT_METHOD_OPTION_VALUE_XML) {
400: content_type="text/xml";
401: listener=new FormatterToXML(writer,
402: XalanDOMString(), // version
403: true, // doIndent
404: XDOC_OUTPUT_DEFAULT_INDENT, // indent
405: xalan_encoding // encoding
406: );
407: } else if(*method == XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML) {
408: content_type="text/html";
409: listener=new FormatterToHTML(writer,
410: xalan_encoding, // encoding
411: XalanDOMString(), // mediaType
412: XalanDOMString(), // doctypeSystem; String to be printed at the top of the document
413: XalanDOMString(), // doctypePublic
414: true, // doIndent
415: XDOC_OUTPUT_DEFAULT_INDENT // indent
416: );
417: } else if(*method == XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT) {
418: content_type="text/plain";
419: listener=new FormatterToText(writer,
420: xalan_encoding // encoding
421: );
422: } else
423: PTHROW(0, 0,
424: method,
425: XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
426: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
427: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "
428: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "'");
429:
430: // never reached
431: }
432:
433: static void _save(Request& r, const String& method_name, MethodParams *params) {
434: Pool& pool=r.pool();
435: VXnode& vnode=*static_cast<VXnode *>(r.self);
436:
437: // filespec
1.20 parser 438: const String& file_name=params->as_string(0, "file name must be string");
1.1 parser 439: const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
440:
441: // node
442: XalanNode& node=vnode.get_node(pool, &method_name);
443:
444: try {
445: XalanFileOutputStream stream(XalanDOMString(filespec, strlen(filespec)));
446: XalanOutputStreamPrintWriter writer(stream);
447: const char *content_type, *charset;
448: FormatterListener *formatterListener;
449: create_optioned_listener(content_type, charset, formatterListener,
450: pool, method_name, params, 1, writer);
451: FormatterTreeWalker treeWalker(*formatterListener);
452: treeWalker.traverse(&node); // Walk that node and produce the XML...
453: } catch(const XSLException& e) {
1.14 parser 454: pool.exception()._throw(pool, &method_name, e);
1.1 parser 455: }
456: }
457:
458: static void _string(Request& r, const String& method_name, MethodParams *params) {
459: Pool& pool=r.pool();
1.21 parser 460: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 461:
462: // node
1.21 parser 463: XalanNode *node=&vdoc.get_document(pool, &method_name);//.getDocumentElement();
464: if(!node)
465: PTHROW(0, 0,
466: &method_name,
467: "no documentElement");
1.1 parser 468:
469: try {
470: String parserString=*new(pool) String(pool);
471: ParserStringXalanOutputStream stream(parserString);
1.23 parser 472: XalanOutputStreamPrintWriter writer(stream);
473: const char *content_type, *charset;
474: FormatterListener *formatterListener;
475: create_optioned_listener(content_type, charset, formatterListener,
476: pool, method_name, params, 0, writer);
477: FormatterTreeWalker treeWalker(*formatterListener);
478: treeWalker.traverse(node); // Walk that node and produce the XML...
1.1 parser 479:
480: // write out result
481: r.write_no_lang(parserString);
482: } catch(const XSLException& e) {
1.14 parser 483: pool.exception()._throw(pool, &method_name, e);
1.1 parser 484: }
485: }
486:
487:
488: static void _file(Request& r, const String& method_name, MethodParams *params) {
489: Pool& pool=r.pool();
490: VXnode& vnode=*static_cast<VXnode *>(r.self);
491:
492: // node
493: XalanNode& node=vnode.get_node(pool, &method_name);
494:
495: try {
496: String& parserString=*new(pool) String(pool);
497: ParserStringXalanOutputStream stream(parserString);
498: XalanOutputStreamPrintWriter writer(stream);
499: const char *content_type, *charset;
500: FormatterListener *formatterListener;
501: create_optioned_listener(content_type, charset, formatterListener,
502: pool, method_name, params, 0, writer);
503: FormatterTreeWalker treeWalker(*formatterListener);
504: treeWalker.traverse(&node); // Walk that node and produce the XML...
505:
506: // write out result
507: VFile& vfile=*new(pool) VFile(pool);
508: const char *cstr=parserString.cstr();
509: String *scontent_type=new(pool) String(pool, content_type);
510: Value *vcontent_type;
511: if(charset) {
512: VHash *vhcontent_type=new(pool) VHash(pool);
513: vhcontent_type->hash().put(*value_name, new(pool) VString(*scontent_type));
514: String *scharset=new(pool) String(pool, charset);
515: vhcontent_type->hash().put(*new(pool) String(pool, "charset"), new(pool) VString(*scharset));
516: vcontent_type=vhcontent_type;
517: } else
518: vcontent_type=new(pool) VString(*scontent_type);
519: vfile.set(false/*tainted*/, cstr, strlen(cstr), 0/*file_name*/, vcontent_type);
520: r.write_no_lang(vfile);
521: } catch(const XSLException& e) {
1.14 parser 522: pool.exception()._throw(pool, &method_name, e);
1.1 parser 523: }
524: }
525:
526: static void _set(Request& r, const String& method_name, MethodParams *params) {
1.15 parser 527: //_asm int 3;
1.1 parser 528: Pool& pool=r.pool();
1.5 parser 529: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 530:
531: Value& vxml=params->as_junction(0, "xml must be code");
532: Temp_lang temp_lang(r, String::UL_XML);
533: const String& xml=r.process(vxml).as_string();
534:
535: std::istrstream stream(xml.cstr());
536: const XalanParsedSource* parsedSource;
1.9 parser 537:
1.11 parser 538: try {
539: parsedSource = new XalanDefaultParsedSource2(&stream);
1.9 parser 540: }
1.10 parser 541: catch (XSLException& e) {
1.14 parser 542: pool.exception()._throw(pool, &method_name, e);
1.10 parser 543: }
544: catch (SAXParseException& e) {
1.14 parser 545: pool.exception()._throw(pool, &method_name, e);
1.9 parser 546: }
1.10 parser 547: catch (SAXException& e) {
1.14 parser 548: pool.exception()._throw(pool, &method_name, e);
1.9 parser 549: }
1.10 parser 550: catch (XMLException& e) {
1.14 parser 551: pool.exception()._throw(pool, &method_name, e);
1.9 parser 552: }
1.16 parser 553: catch(const XalanDOMException& e) {
1.14 parser 554: pool.exception()._throw(pool, &method_name, e);
1.9 parser 555: }
1.1 parser 556:
557: // replace any previous parsed source
1.5 parser 558: vdoc.set_parsed_source(*parsedSource);
1.1 parser 559: }
560:
1.21 parser 561: /// @test free dom_document, xalan_document
1.17 parser 562: static void _create(Request& r, const String& method_name, MethodParams *params) {
563: Pool& pool=r.pool();
564: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
565:
1.21 parser 566: DOM_Document *dom_document=new DOM_Document();
567: *dom_document=DOM_Document::createDocument();
568: /*
1.20 parser 569: const String& squalifiedName=params->as_string(0, "qualifiedName must be string");
1.17 parser 570:
1.21 parser 571: /// +createXMLDecl ?
1.17 parser 572: String xml(pool, "<?xml version=\"1.0\"?>\n");
1.20 parser 573: xml << "<" << squalifiedName.cstr(String::UL_XML) << " />";
1.21 parser 574: */
1.17 parser 575:
1.21 parser 576: XalanDocument& xalan_document=*new XercesDocumentBridge(
577: *dom_document,
578: 0,
579: false /*threadSafe*/,
1.22 parser 580: false /*don' buildBridge -- too early, empty document*/);
1.17 parser 581:
1.21 parser 582: // replace any previous document
583: vdoc.set_document(xalan_document);
1.17 parser 584: }
585:
1.1 parser 586: static void _load(Request& r, const String& method_name, MethodParams *params) {
587: Pool& pool=r.pool();
1.5 parser 588: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 589:
590: // filespec
1.20 parser 591: const String& file_name=params->as_string(0, "file name must be string");
1.1 parser 592: const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
593:
594: const XalanParsedSource* parsedSource;
1.12 parser 595: try {
596: parsedSource = new XalanDefaultParsedSource2(filespec);
597: }
598: catch (XSLException& e) {
1.14 parser 599: pool.exception()._throw(pool, &method_name, e);
1.12 parser 600: }
601: catch (SAXParseException& e) {
1.14 parser 602: pool.exception()._throw(pool, &method_name, e);
1.12 parser 603: }
604: catch (SAXException& e) {
1.14 parser 605: pool.exception()._throw(pool, &method_name, e);
1.12 parser 606: }
607: catch (XMLException& e) {
1.14 parser 608: pool.exception()._throw(pool, &method_name, e);
1.12 parser 609: }
1.16 parser 610: catch(const XalanDOMException& e) {
1.14 parser 611: pool.exception()._throw(pool, &method_name, e);
1.12 parser 612: }
1.1 parser 613:
614: // replace any previous parsed source
1.5 parser 615: vdoc.set_parsed_source(*parsedSource);
1.1 parser 616: }
617:
618: static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,
619: void *info) {
1.13 parser 620: XalanTransformer2& transformer=*static_cast<XalanTransformer2 *>(info);
1.1 parser 621: const char *attribute_cstr=aattribute.cstr();
622: const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr();
623:
624: transformer.setStylesheetParam(
625: XalanDOMString(attribute_cstr),
626: XalanDOMString(meaning_cstr));
627: }
1.24 ! parser 628: /*
1.8 parser 629: static void _transform(Request& r, const String& method_name, MethodParams *params) {
1.1 parser 630: Pool& pool=r.pool();
1.5 parser 631: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 632:
633: // params
634: if(params->size()>1) {
1.20 parser 635: Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
1.1 parser 636: if(vparams.is_defined())
637: if(Hash *params=vparams.get_hash())
1.5 parser 638: params->for_each(add_xslt_param, &vdoc.transformer());
1.1 parser 639: else
640: PTHROW(0, 0,
641: &method_name,
642: "transform parameters parameter must be hash");
643: }
644:
645: // source
1.5 parser 646: const XalanParsedSource &parsed_source=vdoc.get_parsed_source(pool, &method_name);
1.1 parser 647:
648: // stylesheet
1.20 parser 649: const String& stylesheet_file_name=params->as_string(0, "file name must be string");
1.1 parser 650: const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
651: //_asm int 3;
652: Stylesheet_connection& connection=XSLT_stylesheet_manager->get_connection(stylesheet_filespec);
653:
654: // target
1.5 parser 655: XalanDocument* target=vdoc.parser_liaison().createDocument();
1.1 parser 656:
657: // transform
1.13 parser 658: try {
659: vdoc.transformer().transform2(
660: parsed_source,
1.24 ! parser 661: &connection.stylesheet(true/*nocache* /),
! 662: target);
! 663: }
! 664: catch (XSLException& e) {
! 665: connection.close();
! 666: pool.exception()._throw(pool, &stylesheet_file_name, e);
! 667: }
! 668: catch (SAXParseException& e) {
! 669: connection.close();
! 670: pool.exception()._throw(pool, &stylesheet_file_name, e);
! 671: }
! 672: catch (SAXException& e) {
! 673: connection.close();
! 674: pool.exception()._throw(pool, &stylesheet_file_name, e);
! 675: }
! 676: catch (XMLException& e) {
! 677: connection.close();
! 678: pool.exception()._throw(pool, &stylesheet_file_name, e);
! 679: }
! 680: catch(const XalanDOMException& e) {
! 681: connection.close();
! 682: pool.exception()._throw(pool, &stylesheet_file_name, e);
! 683: }
! 684:
! 685: // write out result
! 686: VXdoc& result=*new(pool) VXdoc(pool);
! 687: result.set_document(*target);
! 688: r.write_no_lang(result);
! 689: }
! 690: */
! 691: static void _transform(Request& r, const String& method_name, MethodParams *params) {
! 692: Pool& pool=r.pool();
! 693: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
! 694:
! 695: // params
! 696: if(params->size()>1) {
! 697: Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
! 698: if(vparams.is_defined())
! 699: if(Hash *params=vparams.get_hash())
! 700: params->for_each(add_xslt_param, &vdoc.transformer());
! 701: else
! 702: PTHROW(0, 0,
! 703: &method_name,
! 704: "transform parameters parameter must be hash");
! 705: }
! 706:
! 707: // source
! 708: XalanDocument &xalan_document=vdoc.get_document(pool, &method_name);
! 709:
! 710: // stylesheet
! 711: const String& stylesheet_file_name=params->as_string(0, "file name must be string");
! 712: const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
! 713: //_asm int 3;
! 714: Stylesheet_connection& connection=XSLT_stylesheet_manager->get_connection(stylesheet_filespec);
! 715:
! 716: // target
! 717: XalanDocument* target=vdoc.parser_liaison().createDocument();
! 718:
! 719: // transform
! 720: try {
! 721: vdoc.transformer().transform2(
! 722: &xalan_document,
1.13 parser 723: &connection.stylesheet(true/*nocache*/),
724: target);
725: }
726: catch (XSLException& e) {
727: connection.close();
1.14 parser 728: pool.exception()._throw(pool, &stylesheet_file_name, e);
1.13 parser 729: }
730: catch (SAXParseException& e) {
731: connection.close();
1.14 parser 732: pool.exception()._throw(pool, &stylesheet_file_name, e);
1.13 parser 733: }
734: catch (SAXException& e) {
735: connection.close();
1.14 parser 736: pool.exception()._throw(pool, &stylesheet_file_name, e);
1.13 parser 737: }
738: catch (XMLException& e) {
739: connection.close();
1.14 parser 740: pool.exception()._throw(pool, &stylesheet_file_name, e);
1.13 parser 741: }
1.16 parser 742: catch(const XalanDOMException& e) {
1.13 parser 743: connection.close();
1.14 parser 744: pool.exception()._throw(pool, &stylesheet_file_name, e);
1.13 parser 745: }
1.1 parser 746:
747: // write out result
748: VXdoc& result=*new(pool) VXdoc(pool);
749: result.set_document(*target);
750: r.write_no_lang(result);
751: }
752:
1.2 parser 753: static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
754: Pool& pool=r.pool();
755: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
756:
757: // elementId
1.20 parser 758: const char *elementId=params->as_string(0, "elementID must be string").cstr(String::UL_XML);
1.2 parser 759:
1.16 parser 760: if(XalanNode *node=
1.2 parser 761: vdoc.get_document(pool, &method_name).getElementById(XalanDOMString(elementId))) {
762: // write out result
1.16 parser 763: VXnode& result=*new(pool) VXnode(pool, node);
1.2 parser 764: r.write_no_lang(result);
765: }
766: }
1.16 parser 767: // constructor
1.2 parser 768:
1.16 parser 769: MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
770: set_name(*NEW String(pool(), XDOC_CLASS_NAME));
1.2 parser 771:
1.16 parser 772: /// @test how to create empty type html?
1.2 parser 773:
1.16 parser 774: /// DOM1
1.2 parser 775:
1.16 parser 776: // Element createElement(in DOMString tagName) raises(DOMException);
777: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
778: // DocumentFragment createDocumentFragment();
779: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
780: // Text createTextNode(in DOMString data);
781: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
782: // Comment createComment(in DOMString data);
783: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
784: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
785: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
786: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
787: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
788: // Attr createAttribute(in DOMString name) raises(DOMException);
789: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
790: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
791: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
792: // NodeList getElementsByTagName(in DOMString tagname);
793: /*
794: // ^xdoc.getElementsByTagName[tagname]
795: add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
796:
797: // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
798: add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
799: */
1.2 parser 800:
1.16 parser 801: /// DOM2(?)
1.2 parser 802:
1.16 parser 803: // ^xdoc.getElementById[elementId]
804: add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
1.1 parser 805:
1.16 parser 806: /// parser
807:
1.2 parser 808: // ^xdoc.save[some.xml]
809: // ^xdoc.save[some.xml;options hash]
1.1 parser 810: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
811:
1.2 parser 812: // ^xdoc.string[] <doc/>
813: // ^xdoc.string[options hash] <doc/>
1.1 parser 814: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
815:
1.2 parser 816: // ^xdoc.file[] file with "<doc/>"
817: // ^xdoc.file[options hash] file with "<doc/>"
1.1 parser 818: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
819:
1.2 parser 820: // ^xdoc::set[<some>xml</some>]
1.1 parser 821: add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
1.18 parser 822: // ^xdoc::create{qualifiedName}
1.19 parser 823: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);
1.1 parser 824:
1.2 parser 825: // ^xdoc::load[some.xml]
1.1 parser 826: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
827:
1.8 parser 828: // ^xdoc.transform[stylesheet file_name]
829: // ^xdoc.transform[stylesheet file_name;params hash]
830: add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
1.2 parser 831:
1.1 parser 832: }
1.5 parser 833:
834: void MXdoc::configure_admin(Request& r) {
835: }
836:
1.1 parser 837: // global variable
838:
839: Methoded *Xdoc_class;
840:
841: // creator
842:
843: #endif
844:
845: Methoded *MXdoc_create(Pool& pool) {
846: return
847: #ifdef XML
848: Xdoc_class=new(pool) MXdoc(pool);
849: #else
850: 0
851: #endif
852: ;
853: }
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