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