Annotation of parser3/src/classes/xdoc.C, revision 1.39
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.39 ! paf 7: $Id: xdoc.C,v 1.38 2001/10/29 13:04:46 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.1 parser 45:
46: // defines
47:
48: #define XDOC_CLASS_NAME "xdoc"
49:
50: #define XDOC_OUTPUT_METHOD_OPTION_NAME "method"
51: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"
52: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"
53: #define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"
54:
55: #define XDOC_OUTPUT_ENCODING_OPTION_NAME "encoding"
56:
57: #define XDOC_OUTPUT_DEFAULT_INDENT 4
58:
59: // class
60:
61: class MXdoc : public MXnode {
62: public: // VStateless_class
1.28 parser 63: Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool, 0, false); }
1.1 parser 64:
65: public:
66: MXdoc(Pool& pool);
67:
68: public: // Methoded
69: bool used_directly() { return true; }
1.5 parser 70: void configure_admin(Request& r);
1.1 parser 71: };
72:
73: // methods
74:
1.16 parser 75: // Element createElement(in DOMString tagName) raises(DOMException);
76: static void _createElement(Request& r, const String& method_name, MethodParams *params) {
77: Pool& pool=r.pool();
78: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
79:
1.39 ! paf 80: const String& tagName=params->as_string(0, "tagName must be string");
1.16 parser 81:
82: try {
83: XalanNode *node=
84: vdoc.get_document(pool, &method_name).
1.30 parser 85: createElement(*pool.transcode(tagName));
1.16 parser 86: // write out result
1.31 parser 87: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 88: r.write_no_lang(result);
89: } catch(const XalanDOMException& e) {
1.32 parser 90: Exception::provide_source(pool, &method_name, e);
1.16 parser 91: }
92: }
93:
94: // DocumentFragment createDocumentFragment()
1.26 parser 95: static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {
1.16 parser 96: Pool& pool=r.pool();
97: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
98:
99: XalanNode *node=
100: vdoc.get_document(pool, &method_name).
101: createDocumentFragment();
102: // write out result
1.31 parser 103: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 104: r.write_no_lang(result);
105: }
106:
107: // Text createTextNode(in DOMString data);
108: static void _createTextNode(Request& r, const String& method_name, MethodParams *params) {
109: Pool& pool=r.pool();
110: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
111:
1.37 paf 112: Temp_lang temp_lang(r, String::UL_XML);
113: Value& data_code=params->as_junction(0, "data must be string");
114: const String& data=r.process(data_code).as_string();
1.16 parser 115:
116: XalanNode *node=
117: vdoc.get_document(pool, &method_name).
1.30 parser 118: createTextNode(*pool.transcode(data));
1.16 parser 119: // write out result
1.31 parser 120: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 121: r.write_no_lang(result);
122: }
123:
124: // Comment createComment(in DOMString data)
125: static void _createComment(Request& r, const String& method_name, MethodParams *params) {
126: Pool& pool=r.pool();
127: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
128:
1.26 parser 129: const String& data=params->as_string(0, "data must be string");
1.16 parser 130:
131: XalanNode *node=
132: vdoc.get_document(pool, &method_name).
1.30 parser 133: createComment(*pool.transcode(data));
1.16 parser 134: // write out result
1.31 parser 135: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 136: r.write_no_lang(result);
137: }
138:
139: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
140: static void _createCDATASection(Request& r, const String& method_name, MethodParams *params) {
141: Pool& pool=r.pool();
142: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
143:
1.26 parser 144: const String& data=params->as_string(0, "data must be string");
1.16 parser 145:
146: try {
147: XalanNode *node=
148: vdoc.get_document(pool, &method_name).
1.30 parser 149: createCDATASection(*pool.transcode(data));
1.16 parser 150: // write out result
1.31 parser 151: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 152: r.write_no_lang(result);
153: } catch(const XalanDOMException& e) {
1.32 parser 154: Exception::provide_source(pool, &method_name, e);
1.16 parser 155: }
156: }
157:
158: // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
159: static void _createProcessingInstruction(Request& r, const String& method_name, MethodParams *params) {
160: Pool& pool=r.pool();
161: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
162:
1.26 parser 163: const String& target=params->as_string(0, "data must be string");
164: const String& data=params->as_string(1, "data must be string");
1.16 parser 165:
166: try {
167: XalanNode *node=
168: vdoc.get_document(pool, &method_name).
1.30 parser 169: createProcessingInstruction(*pool.transcode(target), *pool.transcode(data));
1.16 parser 170: // write out result
1.31 parser 171: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 172: r.write_no_lang(result);
173: } catch(const XalanDOMException& e) {
1.32 parser 174: Exception::provide_source(pool, &method_name, e);
1.16 parser 175: }
176: }
177:
178: // Attr createAttribute(in DOMString name) raises(DOMException);
179: static void _createAttribute(Request& r, const String& method_name, MethodParams *params) {
180: Pool& pool=r.pool();
181: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
182:
1.26 parser 183: const String& name=params->as_string(0, "name must be string");
1.16 parser 184:
185: try {
186: XalanNode *node=
187: vdoc.get_document(pool, &method_name).
1.30 parser 188: createAttribute(*pool.transcode(name));
1.16 parser 189: // write out result
1.31 parser 190: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 191: r.write_no_lang(result);
192: } catch(const XalanDOMException& e) {
1.32 parser 193: Exception::provide_source(pool, &method_name, e);
1.16 parser 194: }
195: }
196: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
197: static void _createEntityReference(Request& r, const String& method_name, MethodParams *params) {
198: Pool& pool=r.pool();
199: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
200:
1.26 parser 201: const String& name=params->as_string(0, "name must be string");
1.16 parser 202:
203: try {
204: XalanNode *node=
205: vdoc.get_document(pool, &method_name).
1.30 parser 206: createEntityReference(*pool.transcode(name));
1.16 parser 207: // write out result
1.31 parser 208: VXnode& result=*new(pool) VXnode(pool, node, false);
1.16 parser 209: r.write_no_lang(result);
210: } catch(const XalanDOMException& e) {
1.32 parser 211: Exception::provide_source(pool, &method_name, e);
1.16 parser 212: }
213: }
214:
215: /*
216: static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {
217: Pool& pool=r.pool();
218: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
219:
220: // tagname
1.20 parser 221: const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);
1.16 parser 222:
223: VHash& result=*new(pool) VHash(pool);
224: if(const XalanNodeList *nodes=
225: vdoc.get_document(pool, &method_name).getElementsByTagName(XalanDOMString(name))) {
226: for(int i=0; i<nodes->getLength(); i++) {
227: String& skey=*new(pool) String(pool);
228: {
229: char *buf=(char *)pool.malloc(MAX_NUMBER);
230: snprintf(buf, MAX_NUMBER, "%d", i);
231: skey << buf;
232: }
233:
234: result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));
235: }
236: }
237:
238: // write out result
239: r.write_no_lang(result);
240: }
241:
242: static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams *params) {
243: Pool& pool=r.pool();
244: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
245:
246: // namespaceURI;localName
1.20 parser 247: const char *namespaceURI=params->as_string(0, "namespaceURI must be string").cstr(String::UL_XML);
248: const char *localName=params->as_string(0, "localName must be string").cstr(String::UL_XML);
1.16 parser 249:
250: VHash& result=*new(pool) VHash(pool);
251: if(const XalanNodeList *nodes=
252: vdoc.get_document(pool, &method_name).getElementsByTagNameNS(
253: XalanDOMString(namespaceURI), XalanDOMString(localName))) {
254: for(int i=0; i<nodes->getLength(); i++) {
255: String& skey=*new(pool) String(pool);
256: {
257: char *buf=(char *)pool.malloc(MAX_NUMBER);
258: snprintf(buf, MAX_NUMBER, "%d", i);
259: skey << buf;
260: }
261:
262: result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));
263: }
264: }
265:
266: // write out result
267: r.write_no_lang(result);
268: }
269: */
270:
271:
1.1 parser 272: class ParserStringXalanOutputStream: public XalanOutputStream {
273: public:
274:
275: explicit ParserStringXalanOutputStream(String& astring) : fstring(astring) {}
276:
277: protected: // XalanOutputStream
278:
279: virtual void writeData(const char *theBuffer, unsigned long theBufferLength) {
280: char *copy=(char *)fstring.malloc((size_t)theBufferLength);
281: memcpy(copy, theBuffer, (size_t)theBufferLength);
1.2 parser 282: fstring.APPEND_CLEAN(copy, (size_t)theBufferLength, "xdoc", 0);
1.1 parser 283: }
284:
285: virtual void doFlush() {}
286:
287: private:
288:
289: String& fstring;
290:
291: };
292:
1.9 parser 293: class XalanSourceTreeParserLiaison2: public XalanSourceTreeParserLiaison {
294: public:
1.16 parser 295: XalanSourceTreeParserLiaison2(XalanSourceTreeDOMSupport& theSupport) : XalanSourceTreeParserLiaison(theSupport),
1.9 parser 296: ferror_handler(new HandlerBase) {
297: }
298:
1.10 parser 299: XalanDocument*
300: parseXMLStream2(
1.16 parser 301: const InputSource& inputSource) {
1.10 parser 302: XalanSourceTreeContentHandler theContentHandler(createXalanSourceTreeDocument());
303: XalanAutoPtr<SAX2XMLReader> theReader(XMLReaderFactory::createXMLReader());
304: theReader->setContentHandler(&theContentHandler);
305: theReader->setDTDHandler(&theContentHandler);
306: theReader->setErrorHandler(ferror_handler); // disable stderr output
307: theReader->setLexicalHandler(&theContentHandler);
308: EntityResolver* const theResolver = getEntityResolver();
309: if (theResolver != 0) {
310: theReader->setEntityResolver(theResolver);
311: }
312: theReader->parse(inputSource);
313: return theContentHandler.getDocument();
314: }
315:
1.9 parser 316: ~XalanSourceTreeParserLiaison2() {
1.11 parser 317: delete ferror_handler;
1.9 parser 318: }
319: private:
320: ErrorHandler *ferror_handler;
321: };
322:
323: class XalanDefaultParsedSource2 : public XalanParsedSource
324: {
325: public:
326:
1.16 parser 327: XalanDefaultParsedSource2(const XSLTInputSource& theInputSource);
1.9 parser 328:
329: virtual XalanDocument*
330: getDocument() const;
331:
332: virtual XalanParsedSourceHelper*
333: createHelper() const;
334:
335: private:
336:
337: XalanSourceTreeDOMSupport m_domSupport;
338:
1.10 parser 339: XalanSourceTreeParserLiaison2 m_parserLiaison2;
1.9 parser 340:
341: XalanSourceTreeDocument* const m_parsedSource;
342: };
343:
1.16 parser 344: XalanDefaultParsedSource2::XalanDefaultParsedSource2(const XSLTInputSource& theInputSource):
1.9 parser 345: XalanParsedSource(),
346: m_domSupport(),
1.10 parser 347: m_parserLiaison2(m_domSupport),
348: m_parsedSource(m_parserLiaison2.mapDocument(m_parserLiaison2.parseXMLStream2(theInputSource)))
1.9 parser 349: {
350: assert(m_parsedSource != 0);
351:
1.10 parser 352: m_domSupport.setParserLiaison(&m_parserLiaison2);
1.9 parser 353: }
354:
355:
356:
357: XalanDocument*
358: XalanDefaultParsedSource2::getDocument() const
359: {
360: return m_parsedSource;
361: }
362:
363:
364:
365: XalanParsedSourceHelper*
366: XalanDefaultParsedSource2::createHelper() const
367: {
368: return new XalanDefaultParsedSourceHelper(m_domSupport);
369: }
370:
371:
372:
373:
1.1 parser 374: static void create_optioned_listener(
375: const char *& content_type, const char *& charset, FormatterListener *& listener,
376: Pool& pool,
377: const String& method_name, MethodParams *params, int index, Writer& writer) {
378: // default encoding from pool
379: const String *scharset=&pool.get_charset();
380: const String *method=0;
381: XalanDOMString xalan_encoding;
382:
383: if(params->size()>index) {
1.20 parser 384: Value& voptions=params->as_no_junction(index, "options must be string");
1.1 parser 385: if(voptions.is_defined()) {
1.34 parser 386: if(Hash *options=voptions.get_hash(&method_name)) {
1.1 parser 387: // $.method[xml|html|text]
388: if(Value *vmethod=static_cast<Value *>(options->get(*new(pool)
389: String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
390: method=&vmethod->as_string();
391:
392: // $.encoding[windows-1251|...]
393: if(Value *vencoding=static_cast<Value *>(options->get(*new(pool)
394: String(pool, XDOC_OUTPUT_ENCODING_OPTION_NAME)))) {
395: scharset=&vencoding->as_string();
396: }
1.19 parser 397: }
1.1 parser 398: }
399: }
400:
401: xalan_encoding.append(charset=scharset->cstr());
402: if(!method/*default='xml'*/ || *method == XDOC_OUTPUT_METHOD_OPTION_VALUE_XML) {
403: content_type="text/xml";
404: listener=new FormatterToXML(writer,
405: XalanDOMString(), // version
406: true, // doIndent
407: XDOC_OUTPUT_DEFAULT_INDENT, // indent
408: xalan_encoding // encoding
409: );
410: } else if(*method == XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML) {
411: content_type="text/html";
412: listener=new FormatterToHTML(writer,
413: xalan_encoding, // encoding
414: XalanDOMString(), // mediaType
415: XalanDOMString(), // doctypeSystem; String to be printed at the top of the document
416: XalanDOMString(), // doctypePublic
417: true, // doIndent
418: XDOC_OUTPUT_DEFAULT_INDENT // indent
419: );
420: } else if(*method == XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT) {
421: content_type="text/plain";
422: listener=new FormatterToText(writer,
423: xalan_encoding // encoding
424: );
425: } else
1.29 parser 426: throw Exception(0, 0,
1.1 parser 427: method,
428: XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
429: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
430: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "
431: "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "'");
432:
433: // never reached
434: }
435:
436: static void _save(Request& r, const String& method_name, MethodParams *params) {
437: Pool& pool=r.pool();
438: VXnode& vnode=*static_cast<VXnode *>(r.self);
439:
440: // filespec
1.20 parser 441: const String& file_name=params->as_string(0, "file name must be string");
1.1 parser 442: const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
443:
444: // node
445: XalanNode& node=vnode.get_node(pool, &method_name);
446:
447: try {
448: XalanFileOutputStream stream(XalanDOMString(filespec, strlen(filespec)));
449: XalanOutputStreamPrintWriter writer(stream);
450: const char *content_type, *charset;
451: FormatterListener *formatterListener;
452: create_optioned_listener(content_type, charset, formatterListener,
453: pool, method_name, params, 1, writer);
454: FormatterTreeWalker treeWalker(*formatterListener);
455: treeWalker.traverse(&node); // Walk that node and produce the XML...
456: } catch(const XSLException& e) {
1.32 parser 457: Exception::provide_source(pool, &method_name, e);
1.1 parser 458: }
459: }
460:
461: static void _string(Request& r, const String& method_name, MethodParams *params) {
462: Pool& pool=r.pool();
1.21 parser 463: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 464:
465: // node
1.21 parser 466: XalanNode *node=&vdoc.get_document(pool, &method_name);//.getDocumentElement();
467: if(!node)
1.29 parser 468: throw Exception(0, 0,
1.21 parser 469: &method_name,
470: "no documentElement");
1.1 parser 471:
472: try {
473: String parserString=*new(pool) String(pool);
474: ParserStringXalanOutputStream stream(parserString);
1.23 parser 475: XalanOutputStreamPrintWriter writer(stream);
476: const char *content_type, *charset;
477: FormatterListener *formatterListener;
478: create_optioned_listener(content_type, charset, formatterListener,
479: pool, method_name, params, 0, writer);
480: FormatterTreeWalker treeWalker(*formatterListener);
481: treeWalker.traverse(node); // Walk that node and produce the XML...
1.1 parser 482:
483: // write out result
484: r.write_no_lang(parserString);
485: } catch(const XSLException& e) {
1.32 parser 486: Exception::provide_source(pool, &method_name, e);
1.1 parser 487: }
488: }
489:
490:
491: static void _file(Request& r, const String& method_name, MethodParams *params) {
492: Pool& pool=r.pool();
493: VXnode& vnode=*static_cast<VXnode *>(r.self);
494:
495: // node
496: XalanNode& node=vnode.get_node(pool, &method_name);
497:
498: try {
499: String& parserString=*new(pool) String(pool);
500: ParserStringXalanOutputStream stream(parserString);
501: XalanOutputStreamPrintWriter writer(stream);
502: const char *content_type, *charset;
503: FormatterListener *formatterListener;
504: create_optioned_listener(content_type, charset, formatterListener,
505: pool, method_name, params, 0, writer);
506: FormatterTreeWalker treeWalker(*formatterListener);
507: treeWalker.traverse(&node); // Walk that node and produce the XML...
508:
509: // write out result
510: VFile& vfile=*new(pool) VFile(pool);
511: const char *cstr=parserString.cstr();
512: String *scontent_type=new(pool) String(pool, content_type);
513: Value *vcontent_type;
514: if(charset) {
515: VHash *vhcontent_type=new(pool) VHash(pool);
516: vhcontent_type->hash().put(*value_name, new(pool) VString(*scontent_type));
517: String *scharset=new(pool) String(pool, charset);
518: vhcontent_type->hash().put(*new(pool) String(pool, "charset"), new(pool) VString(*scharset));
519: vcontent_type=vhcontent_type;
520: } else
521: vcontent_type=new(pool) VString(*scontent_type);
522: vfile.set(false/*tainted*/, cstr, strlen(cstr), 0/*file_name*/, vcontent_type);
523: r.write_no_lang(vfile);
524: } catch(const XSLException& e) {
1.32 parser 525: Exception::provide_source(pool, &method_name, e);
1.1 parser 526: }
527: }
528:
529: static void _set(Request& r, const String& method_name, MethodParams *params) {
1.15 parser 530: //_asm int 3;
1.1 parser 531: Pool& pool=r.pool();
1.5 parser 532: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 533:
534: Value& vxml=params->as_junction(0, "xml must be code");
535: Temp_lang temp_lang(r, String::UL_XML);
536: const String& xml=r.process(vxml).as_string();
537:
538: std::istrstream stream(xml.cstr());
539: const XalanParsedSource* parsedSource;
1.9 parser 540:
1.11 parser 541: try {
542: parsedSource = new XalanDefaultParsedSource2(&stream);
1.9 parser 543: }
1.10 parser 544: catch (XSLException& e) {
1.32 parser 545: Exception::provide_source(pool, &method_name, e);
1.10 parser 546: }
547: catch (SAXParseException& e) {
1.32 parser 548: Exception::provide_source(pool, &method_name, e);
1.9 parser 549: }
1.10 parser 550: catch (SAXException& e) {
1.32 parser 551: Exception::provide_source(pool, &method_name, e);
1.9 parser 552: }
1.10 parser 553: catch (XMLException& e) {
1.32 parser 554: Exception::provide_source(pool, &method_name, e);
1.9 parser 555: }
1.16 parser 556: catch(const XalanDOMException& e) {
1.32 parser 557: Exception::provide_source(pool, &method_name, e);
1.9 parser 558: }
1.1 parser 559:
560: // replace any previous parsed source
1.5 parser 561: vdoc.set_parsed_source(*parsedSource);
1.1 parser 562: }
563:
1.17 parser 564: static void _create(Request& r, const String& method_name, MethodParams *params) {
1.27 parser 565: //_asm int 3;
1.17 parser 566: Pool& pool=r.pool();
567: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
568:
1.26 parser 569: const String& qualifiedName=params->as_string(0, "qualifiedName must be string");
1.17 parser 570:
1.25 parser 571: XalanDocument& document=*new XercesDocumentBridge(
572: DOM_Document::createDocument(),
1.21 parser 573: 0,
574: false /*threadSafe*/,
1.22 parser 575: false /*don' buildBridge -- too early, empty document*/);
1.17 parser 576:
1.25 parser 577: /// +createXMLDecl ?
1.30 parser 578: document.appendChild(document.createElement(*pool.transcode(qualifiedName)));
1.25 parser 579:
1.21 parser 580: // replace any previous document
1.28 parser 581: vdoc.set_document(document, true/*owns*/);
1.17 parser 582: }
583:
1.1 parser 584: static void _load(Request& r, const String& method_name, MethodParams *params) {
585: Pool& pool=r.pool();
1.5 parser 586: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
1.1 parser 587:
588: // filespec
1.20 parser 589: const String& file_name=params->as_string(0, "file name must be string");
1.1 parser 590: const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
591:
592: const XalanParsedSource* parsedSource;
1.12 parser 593: try {
594: parsedSource = new XalanDefaultParsedSource2(filespec);
595: }
596: catch (XSLException& e) {
1.32 parser 597: Exception::provide_source(pool, &method_name, e);
1.12 parser 598: }
599: catch (SAXParseException& e) {
1.32 parser 600: Exception::provide_source(pool, &method_name, e);
1.12 parser 601: }
602: catch (SAXException& e) {
1.32 parser 603: Exception::provide_source(pool, &method_name, e);
1.12 parser 604: }
605: catch (XMLException& e) {
1.32 parser 606: Exception::provide_source(pool, &method_name, e);
1.12 parser 607: }
1.16 parser 608: catch(const XalanDOMException& e) {
1.32 parser 609: Exception::provide_source(pool, &method_name, e);
1.12 parser 610: }
1.1 parser 611:
612: // replace any previous parsed source
1.5 parser 613: vdoc.set_parsed_source(*parsedSource);
1.1 parser 614: }
615:
1.38 paf 616: /// @test lang=String::UL_UNSPECIFIED?
1.1 parser 617: static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,
618: void *info) {
1.13 parser 619: XalanTransformer2& transformer=*static_cast<XalanTransformer2 *>(info);
1.38 paf 620: const char *attribute_cstr=aattribute.cstr(String::UL_UNSPECIFIED);
621: const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr(String::UL_UNSPECIFIED);
1.1 parser 622:
623: transformer.setStylesheetParam(
624: XalanDOMString(attribute_cstr),
625: XalanDOMString(meaning_cstr));
626: }
627:
1.24 parser 628: static void _transform(Request& r, const String& method_name, MethodParams *params) {
629: Pool& pool=r.pool();
630: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
631:
632: // params
633: if(params->size()>1) {
634: Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
635: if(vparams.is_defined())
1.34 parser 636: if(Hash *params=vparams.get_hash(&method_name))
1.24 parser 637: params->for_each(add_xslt_param, &vdoc.transformer());
638: else
1.29 parser 639: throw Exception(0, 0,
1.24 parser 640: &method_name,
641: "transform parameters parameter must be hash");
642: }
643:
644: // stylesheet
645: const String& stylesheet_file_name=params->as_string(0, "file name must be string");
646: const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
647: //_asm int 3;
1.32 parser 648: Stylesheet_connection& connection=stylesheet_manager->get_connection(stylesheet_filespec);
1.24 parser 649:
650: // target
1.35 paf 651: XalanDocument* target=vdoc.parser_xerces_liaison().createDocument();
1.24 parser 652:
653: // transform
654: try {
1.36 paf 655: // note:
656: // actually, never found any difference between the two
657: // but still there some extra "xerces" words at start of transform body
658: // wich were originally "xalan"
659: // not daring to change that
1.35 paf 660: if(vdoc.has_parsed_source()) { // set|load, not create?
661: vdoc.transformer().transform2(
662: vdoc.get_parsed_source(pool, &method_name),
663: &connection.stylesheet(true/*nocache*/),
664: target);
665: } else {
666: target=vdoc.parser_xerces_liaison().createDocument();
667: vdoc.transformer().transform2(
668: vdoc.get_document(pool, &method_name),
669: &connection.stylesheet(true/*nocache*/),
670: target);
671: }
1.13 parser 672: }
673: catch (XSLException& e) {
674: connection.close();
1.32 parser 675: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 676: }
677: catch (SAXParseException& e) {
678: connection.close();
1.32 parser 679: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 680: }
681: catch (SAXException& e) {
682: connection.close();
1.32 parser 683: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 684: }
685: catch (XMLException& e) {
686: connection.close();
1.32 parser 687: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 688: }
1.16 parser 689: catch(const XalanDOMException& e) {
1.13 parser 690: connection.close();
1.32 parser 691: Exception::provide_source(pool, &stylesheet_file_name, e);
1.13 parser 692: }
1.1 parser 693:
694: // write out result
1.28 parser 695: VXdoc& result=*new(pool) VXdoc(pool, target, false/*owns not*/);
1.1 parser 696: r.write_no_lang(result);
697: }
698:
1.2 parser 699: static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
700: Pool& pool=r.pool();
701: VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
702:
703: // elementId
1.26 parser 704: const String& elementId=params->as_string(0, "elementID must be string");
1.2 parser 705:
1.16 parser 706: if(XalanNode *node=
1.30 parser 707: vdoc.get_document(pool, &method_name).getElementById(*pool.transcode(elementId))) {
1.2 parser 708: // write out result
1.31 parser 709: VXnode& result=*new(pool) VXnode(pool, node, false);
1.2 parser 710: r.write_no_lang(result);
711: }
712: }
1.16 parser 713: // constructor
1.2 parser 714:
1.16 parser 715: MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
716: set_name(*NEW String(pool(), XDOC_CLASS_NAME));
1.2 parser 717:
1.16 parser 718: /// @test how to create empty type html?
1.2 parser 719:
1.16 parser 720: /// DOM1
1.2 parser 721:
1.16 parser 722: // Element createElement(in DOMString tagName) raises(DOMException);
723: add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
724: // DocumentFragment createDocumentFragment();
725: add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
726: // Text createTextNode(in DOMString data);
727: add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
728: // Comment createComment(in DOMString data);
729: add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
730: // CDATASection createCDATASection(in DOMString data) raises(DOMException);
731: add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
732: // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
733: add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
734: // Attr createAttribute(in DOMString name) raises(DOMException);
735: add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
736: // EntityReference createEntityReference(in DOMString name) raises(DOMException);
737: add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
738: // NodeList getElementsByTagName(in DOMString tagname);
739: /*
740: // ^xdoc.getElementsByTagName[tagname]
741: add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
742:
743: // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
744: add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
745: */
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.2 parser 754: // ^xdoc.save[some.xml]
755: // ^xdoc.save[some.xml;options hash]
1.1 parser 756: add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
757:
1.2 parser 758: // ^xdoc.string[] <doc/>
759: // ^xdoc.string[options hash] <doc/>
1.1 parser 760: add_native_method("string", Method::CT_DYNAMIC, _string, 0, 1);
761:
1.2 parser 762: // ^xdoc.file[] file with "<doc/>"
763: // ^xdoc.file[options hash] file with "<doc/>"
1.1 parser 764: add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
765:
1.2 parser 766: // ^xdoc::set[<some>xml</some>]
1.1 parser 767: add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
1.18 parser 768: // ^xdoc::create{qualifiedName}
1.19 parser 769: add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);
1.1 parser 770:
1.2 parser 771: // ^xdoc::load[some.xml]
1.1 parser 772: add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
773:
1.8 parser 774: // ^xdoc.transform[stylesheet file_name]
775: // ^xdoc.transform[stylesheet file_name;params hash]
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