[BACK]Return to xdoc.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/xdoc.C between versions 1.2 and 1.32

version 1.2, 2001/09/26 15:43:59 version 1.32, 2001/10/22 16:44:42
Line 6 Line 6
   
         $Id$          $Id$
 */  */
   #include "pa_types.h"
 #include "classes.h"  #include "classes.h"
 #ifdef XML  #ifdef XML
   
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_vxdoc.h"  #include "pa_vxdoc.h"
 #include "pa_xslt_stylesheet_manager.h"  #include "pa_stylesheet_manager.h"
 #include "pa_stylesheet_connection.h"  #include "pa_stylesheet_connection.h"
 #include "pa_vfile.h"  #include "pa_vfile.h"
 #include "xnode.h"  #include "xnode.h"
Line 19 Line 20
 #include <strstream>  #include <strstream>
 #include <Include/PlatformDefinitions.hpp>  #include <Include/PlatformDefinitions.hpp>
 #include <util/PlatformUtils.hpp>  #include <util/PlatformUtils.hpp>
 #include <XalanTransformer/XalanTransformer.hpp>  #include <util/TransENameMap.hpp>
   #include "XalanTransformer2.hpp"
 #include <XalanTransformer/XalanParsedSource.hpp>  #include <XalanTransformer/XalanParsedSource.hpp>
   #       include <XalanTransformer/XalanDefaultParsedSource.hpp>
   #       include <XalanSourceTree/XalanSourceTreeDocument.hpp>
   #       include <XalanSourceTree/XalanSourceTreeContentHandler.hpp>
   #       include <sax2/XMLReaderFactory.hpp>
 #include <XMLSupport/FormatterToXML.hpp>  #include <XMLSupport/FormatterToXML.hpp>
 #include <XMLSupport/FormatterToHTML.hpp>  #include <XMLSupport/FormatterToHTML.hpp>
 #include <XMLSupport/FormatterToText.hpp>  #include <XMLSupport/FormatterToText.hpp>
Line 30 Line 36
 #include <PlatformSupport/DOMStringPrintWriter.hpp>  #include <PlatformSupport/DOMStringPrintWriter.hpp>
 #include <XalanDOM/XalanElement.hpp>  #include <XalanDOM/XalanElement.hpp>
 #include <XalanDOM/XalanNodeList.hpp>  #include <XalanDOM/XalanNodeList.hpp>
   #include <XalanDOM/XalanDocumentFragment.hpp>
   #include <XalanDOM/XalanCDATASection.hpp>
   #include <XalanDOM/XalanEntityReference.hpp>
   #include <dom/DOM_Document.hpp>
   #include <XercesParserLiaison/XercesDocumentBridge.hpp>
   #include <XalanTransformer/XercesDOMParsedSource.hpp>
   
 // defines  // defines
   
Line 48 Line 60
   
 class MXdoc : public MXnode {  class MXdoc : public MXnode {
 public: // VStateless_class  public: // VStateless_class
         Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool); }          Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool, 0, false); }
   
 public:  public:
         MXdoc(Pool& pool);          MXdoc(Pool& pool);
   
 public: // Methoded  public: // Methoded
         bool used_directly() { return true; }          bool used_directly() { return true; }
           void configure_admin(Request& r);
 };  };
   
 // methods  // methods
   
   // Element createElement(in DOMString tagName) raises(DOMException);
   static void _createElement(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& tagName=params->as_string(0, "tagName must be string");
   
           try {
                   XalanNode *node=
                           vdoc.get_document(pool, &method_name).
                           createElement(*pool.transcode(tagName));
                   // write out result
                   VXnode& result=*new(pool) VXnode(pool, node, false);
                   r.write_no_lang(result);
           } catch(const XalanDOMException& e)     {
                   Exception::provide_source(pool, &method_name, e);
           }
   }
   
   // DocumentFragment createDocumentFragment()
   static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           XalanNode *node=
                   vdoc.get_document(pool, &method_name).
                   createDocumentFragment();
           // write out result
           VXnode& result=*new(pool) VXnode(pool, node, false);
           r.write_no_lang(result);
   }
   
   // Text createTextNode(in DOMString data);
   static void _createTextNode(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& data=params->as_string(0, "data must be string");
   
           XalanNode *node=
                   vdoc.get_document(pool, &method_name).
                   createTextNode(*pool.transcode(data));
           // write out result
           VXnode& result=*new(pool) VXnode(pool, node, false);
           r.write_no_lang(result);
   }
   
   // Comment createComment(in DOMString data)
   static void _createComment(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& data=params->as_string(0, "data must be string");
   
           XalanNode *node=
                   vdoc.get_document(pool, &method_name).
                   createComment(*pool.transcode(data));
           // write out result
           VXnode& result=*new(pool) VXnode(pool, node, false);
           r.write_no_lang(result);
   }
   
   // CDATASection createCDATASection(in DOMString data) raises(DOMException);
   static void _createCDATASection(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& data=params->as_string(0, "data must be string");
   
           try {
                   XalanNode *node=
                           vdoc.get_document(pool, &method_name).
                           createCDATASection(*pool.transcode(data));
                   // write out result
                   VXnode& result=*new(pool) VXnode(pool, node, false);
                   r.write_no_lang(result);
           } catch(const XalanDOMException& e)     {
                   Exception::provide_source(pool, &method_name, e);
           }
   }
   
   // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
   static void _createProcessingInstruction(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& target=params->as_string(0, "data must be string");
           const String& data=params->as_string(1, "data must be string");
   
           try {
                   XalanNode *node=
                           vdoc.get_document(pool, &method_name).
                           createProcessingInstruction(*pool.transcode(target), *pool.transcode(data));
                   // write out result
                   VXnode& result=*new(pool) VXnode(pool, node, false);
                   r.write_no_lang(result);
           } catch(const XalanDOMException& e)     {
                   Exception::provide_source(pool, &method_name, e);
           }
   }
   
   // Attr createAttribute(in DOMString name) raises(DOMException);
   static void _createAttribute(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& name=params->as_string(0, "name must be string");
   
           try {
                   XalanNode *node=
                           vdoc.get_document(pool, &method_name).
                           createAttribute(*pool.transcode(name));
                   // write out result
                   VXnode& result=*new(pool) VXnode(pool, node, false);
                   r.write_no_lang(result);
           } catch(const XalanDOMException& e)     {
                   Exception::provide_source(pool, &method_name, e);
           }
   }
   // EntityReference createEntityReference(in DOMString name) raises(DOMException);
   static void _createEntityReference(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& name=params->as_string(0, "name must be string");
   
           try {
                   XalanNode *node=
                           vdoc.get_document(pool, &method_name).
                           createEntityReference(*pool.transcode(name));
                   // write out result
                   VXnode& result=*new(pool) VXnode(pool, node, false);
                   r.write_no_lang(result);
           } catch(const XalanDOMException& e)     {
                   Exception::provide_source(pool, &method_name, e);
           }
   }
   
   /*
   static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           // tagname
           const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);
   
           VHash& result=*new(pool) VHash(pool);
           if(const XalanNodeList *nodes=
                   vdoc.get_document(pool, &method_name).getElementsByTagName(XalanDOMString(name))) {
                   for(int i=0; i<nodes->getLength(); i++) {
                           String& skey=*new(pool) String(pool);
                           {
                                   char *buf=(char *)pool.malloc(MAX_NUMBER);
                                   snprintf(buf, MAX_NUMBER, "%d", i);
                                   skey << buf;
                           }
   
                           result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));
                   }
           }
   
           // write out result
           r.write_no_lang(result);
   }
   
   static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           // namespaceURI;localName
           const char *namespaceURI=params->as_string(0, "namespaceURI must be string").cstr(String::UL_XML);
           const char *localName=params->as_string(0, "localName must be string").cstr(String::UL_XML);
   
           VHash& result=*new(pool) VHash(pool);
           if(const XalanNodeList *nodes=
                   vdoc.get_document(pool, &method_name).getElementsByTagNameNS(
                           XalanDOMString(namespaceURI), XalanDOMString(localName))) {
                   for(int i=0; i<nodes->getLength(); i++) {
                           String& skey=*new(pool) String(pool);
                           {
                                   char *buf=(char *)pool.malloc(MAX_NUMBER);
                                   snprintf(buf, MAX_NUMBER, "%d", i);
                                   skey << buf;
                           }
   
                           result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));
                   }
           }
   
           // write out result
           r.write_no_lang(result);
   }
   */
   
   
 class ParserStringXalanOutputStream: public XalanOutputStream {  class ParserStringXalanOutputStream: public XalanOutputStream {
 public:  public:
                   
Line 80  private: Line 288  private:
                   
 };  };
   
   class XalanSourceTreeParserLiaison2: public XalanSourceTreeParserLiaison {
   public:
           XalanSourceTreeParserLiaison2(XalanSourceTreeDOMSupport&        theSupport) : XalanSourceTreeParserLiaison(theSupport), 
                   ferror_handler(new HandlerBase) {
           }
   
           XalanDocument*
           parseXMLStream2(
                                   const InputSource&      inputSource) {
                   XalanSourceTreeContentHandler   theContentHandler(createXalanSourceTreeDocument());
                   XalanAutoPtr<SAX2XMLReader>             theReader(XMLReaderFactory::createXMLReader());
                   theReader->setContentHandler(&theContentHandler);
                   theReader->setDTDHandler(&theContentHandler);
                   theReader->setErrorHandler(ferror_handler); // disable stderr output
                   theReader->setLexicalHandler(&theContentHandler);
                   EntityResolver* const   theResolver = getEntityResolver();
                   if (theResolver != 0) {
                           theReader->setEntityResolver(theResolver);
                   }
                   theReader->parse(inputSource);
                   return theContentHandler.getDocument();
           }
           
           ~XalanSourceTreeParserLiaison2() {
                   delete ferror_handler;
           }
   private:
           ErrorHandler *ferror_handler;
   };
   
   class XalanDefaultParsedSource2 : public XalanParsedSource
   {
   public:
   
           XalanDefaultParsedSource2(const XSLTInputSource&        theInputSource);
   
           virtual XalanDocument*
           getDocument() const;
   
           virtual XalanParsedSourceHelper*
           createHelper() const;
   
   private:
   
           XalanSourceTreeDOMSupport               m_domSupport;
   
           XalanSourceTreeParserLiaison2   m_parserLiaison2;
   
           XalanSourceTreeDocument* const  m_parsedSource;
   };
   
   XalanDefaultParsedSource2::XalanDefaultParsedSource2(const XSLTInputSource& theInputSource):
           XalanParsedSource(),
           m_domSupport(),
           m_parserLiaison2(m_domSupport),
           m_parsedSource(m_parserLiaison2.mapDocument(m_parserLiaison2.parseXMLStream2(theInputSource)))
   {
           assert(m_parsedSource != 0);
   
           m_domSupport.setParserLiaison(&m_parserLiaison2);
   }
   
   
   
   XalanDocument*  
   XalanDefaultParsedSource2::getDocument() const
   {
           return m_parsedSource;
   }
   
   
   
   XalanParsedSourceHelper*
   XalanDefaultParsedSource2::createHelper() const
   {
           return new XalanDefaultParsedSourceHelper(m_domSupport);
   }
   
   
   
   
 static void create_optioned_listener(  static void create_optioned_listener(
                                                                          const char *& content_type, const char *& charset, FormatterListener *& listener,                                                                            const char *& content_type, const char *& charset, FormatterListener *& listener, 
                                                                          Pool& pool,                                                                            Pool& pool, 
Line 90  static void create_optioned_listener( Line 379  static void create_optioned_listener(
         XalanDOMString xalan_encoding;          XalanDOMString xalan_encoding;
   
         if(params->size()>index) {          if(params->size()>index) {
                 Value& voptions=params->as_no_junction(index, "options must not be code");                  Value& voptions=params->as_no_junction(index, "options must be string");
                 if(voptions.is_defined()) {                  if(voptions.is_defined()) {
                         if(Hash *options=voptions.get_hash()) {                          if(Hash *options=voptions.get_hash()) {
                                 // $.method[xml|html|text]                                  // $.method[xml|html|text]
Line 103  static void create_optioned_listener( Line 392  static void create_optioned_listener(
                                         String(pool, XDOC_OUTPUT_ENCODING_OPTION_NAME)))) {                                          String(pool, XDOC_OUTPUT_ENCODING_OPTION_NAME)))) {
                                         scharset=&vencoding->as_string();                                          scharset=&vencoding->as_string();
                                 }                                  }
                         } else                          }
                                 PTHROW(0, 0,  
                                         &method_name,  
                                         "options must be hash");  
                 }                  }
         }          }
   
Line 135  static void create_optioned_listener( Line 421  static void create_optioned_listener(
                         xalan_encoding  // encoding                          xalan_encoding  // encoding
                 );                  );
         } else          } else
                 PTHROW(0, 0,                  throw Exception(0, 0,
                         method,                          method,
                         XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "                          XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
                                 "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "                                  "'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
Line 150  static void _save(Request& r, const Stri Line 436  static void _save(Request& r, const Stri
         VXnode& vnode=*static_cast<VXnode *>(r.self);          VXnode& vnode=*static_cast<VXnode *>(r.self);
   
         // filespec          // filespec
         const String& file_name=params->as_string(0, "file name must not be code");          const String& file_name=params->as_string(0, "file name must be string");
         const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);          const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
                   
         // node          // node
Line 166  static void _save(Request& r, const Stri Line 452  static void _save(Request& r, const Stri
                 FormatterTreeWalker treeWalker(*formatterListener);                  FormatterTreeWalker treeWalker(*formatterListener);
                 treeWalker.traverse(&node); // Walk that node and produce the XML...                  treeWalker.traverse(&node); // Walk that node and produce the XML...
         } catch(const XSLException& e) {          } catch(const XSLException& e) {
                 r._throw(&method_name, e);                  Exception::provide_source(pool, &method_name, e);
         }          }
 }  }
   
 static void _string(Request& r, const String& method_name, MethodParams *params) {  static void _string(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VXnode& vnode=*static_cast<VXnode *>(r.self);          VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
         // node          // node
         XalanNode& node=vnode.get_node(pool, &method_name);          XalanNode *node=&vdoc.get_document(pool, &method_name);//.getDocumentElement();
           if(!node)
                   throw Exception(0, 0,
                           &method_name,
                           "no documentElement");
   
         try {          try {
                 String parserString=*new(pool) String(pool);                  String parserString=*new(pool) String(pool);
Line 186  static void _string(Request& r, const St Line 476  static void _string(Request& r, const St
                 create_optioned_listener(content_type, charset, formatterListener,                   create_optioned_listener(content_type, charset, formatterListener, 
                         pool, method_name, params, 0, writer);                          pool, method_name, params, 0, writer);
                 FormatterTreeWalker treeWalker(*formatterListener);                  FormatterTreeWalker treeWalker(*formatterListener);
                 treeWalker.traverse(&node); // Walk that node and produce the XML...                  treeWalker.traverse(node); // Walk that node and produce the XML...
   
                 // write out result                  // write out result
                 r.write_no_lang(parserString);                  r.write_no_lang(parserString);
         } catch(const XSLException& e) {          } catch(const XSLException& e) {
                 r._throw(&method_name, e);                  Exception::provide_source(pool, &method_name, e);
         }          }
 }  }
   
Line 230  static void _file(Request& r, const Stri Line 520  static void _file(Request& r, const Stri
                 vfile.set(false/*tainted*/, cstr, strlen(cstr), 0/*file_name*/, vcontent_type);                  vfile.set(false/*tainted*/, cstr, strlen(cstr), 0/*file_name*/, vcontent_type);
                 r.write_no_lang(vfile);                  r.write_no_lang(vfile);
         } catch(const XSLException& e) {          } catch(const XSLException& e) {
                 r._throw(&method_name, e);                  Exception::provide_source(pool, &method_name, e);
         }          }
 }  }
   
 static void _set(Request& r, const String& method_name, MethodParams *params) {  static void _set(Request& r, const String& method_name, MethodParams *params) {
           //_asm int 3;
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VXdoc& vdom=*static_cast<VXdoc *>(r.self);          VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
         Value& vxml=params->as_junction(0, "xml must be code");          Value& vxml=params->as_junction(0, "xml must be code");
         Temp_lang temp_lang(r, String::UL_XML);          Temp_lang temp_lang(r, String::UL_XML);
Line 244  static void _set(Request& r, const Strin Line 535  static void _set(Request& r, const Strin
   
         std::istrstream stream(xml.cstr());          std::istrstream stream(xml.cstr());
         const XalanParsedSource* parsedSource;          const XalanParsedSource* parsedSource;
         int error=vdom.transformer().parseSource(&stream, parsedSource);  
   
         if(error)          try {
                 PTHROW(0, 0,                  parsedSource = new XalanDefaultParsedSource2(&stream);
                         &method_name,          }
                         vdom.transformer().getLastError());          catch (XSLException& e) {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch (SAXParseException& e)    {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch (SAXException& e) {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch (XMLException& e) {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch(const XalanDOMException& e)       {
                   Exception::provide_source(pool, &method_name, e);
           }
   
         // replace any previous parsed source          // replace any previous parsed source
         vdom.set_parsed_source(*parsedSource);          vdoc.set_parsed_source(*parsedSource);
   }
   
   static void _create(Request& r, const String& method_name, MethodParams *params) {
           //_asm int 3;
           Pool& pool=r.pool();
           VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
           const String& qualifiedName=params->as_string(0, "qualifiedName must be string");
   
           XalanDocument& document=*new XercesDocumentBridge(
                   DOM_Document::createDocument(),
                   0,
                   false /*threadSafe*/,
                   false /*don' buildBridge -- too early, empty document*/);
   
           /// +createXMLDecl ?
           document.appendChild(document.createElement(*pool.transcode(qualifiedName)));
   
           // replace any previous document
           vdoc.set_document(document, true/*owns*/);
 }  }
   
 static void _load(Request& r, const String& method_name, MethodParams *params) {  static void _load(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VXdoc& vdom=*static_cast<VXdoc *>(r.self);          VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
         // filespec          // filespec
         const String& file_name=params->as_string(0, "file name must not be code");          const String& file_name=params->as_string(0, "file name must be string");
         const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);          const char *filespec=r.absolute(file_name).cstr(String::UL_FILE_SPEC);
                   
         const XalanParsedSource* parsedSource;          const XalanParsedSource* parsedSource;
         int error=vdom.transformer().parseSource(filespec, parsedSource);          try {
                   parsedSource = new XalanDefaultParsedSource2(filespec);
         if(error)          }
                 PTHROW(0, 0,          catch (XSLException& e) {
                         &file_name,                  Exception::provide_source(pool, &method_name, e);
                         vdom.transformer().getLastError());          }
           catch (SAXParseException& e)    {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch (SAXException& e) {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch (XMLException& e) {
                   Exception::provide_source(pool, &method_name, e);
           }
           catch(const XalanDOMException& e)       {
                   Exception::provide_source(pool, &method_name, e);
           }
   
         // replace any previous parsed source          // replace any previous parsed source
         vdom.set_parsed_source(*parsedSource);          vdoc.set_parsed_source(*parsedSource);
 }  }
   
 static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,   static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning, 
                                                    void *info) {                                                     void *info) {
         XalanTransformer& transformer=*static_cast<XalanTransformer *>(info);          XalanTransformer2& transformer=*static_cast<XalanTransformer2 *>(info);
         const char *attribute_cstr=aattribute.cstr();          const char *attribute_cstr=aattribute.cstr();
         const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr();          const char *meaning_cstr=static_cast<Value *>(ameaning)->as_string().cstr();
   
Line 285  static void add_xslt_param(const Hash::K Line 621  static void add_xslt_param(const Hash::K
                 XalanDOMString(attribute_cstr),                    XalanDOMString(attribute_cstr),  
                 XalanDOMString(meaning_cstr));                  XalanDOMString(meaning_cstr));
 }  }
 static void _xslt(Request& r, const String& method_name, MethodParams *params) {  /*
   static void _transform(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VXdoc& vdom=*static_cast<VXdoc *>(r.self);          VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
         // params          // params
         if(params->size()>1) {          if(params->size()>1) {
                 Value& vparams=params->as_no_junction(1, "transform parameters parameter must not be code");                  Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
                 if(vparams.is_defined())                  if(vparams.is_defined())
                         if(Hash *params=vparams.get_hash())                          if(Hash *params=vparams.get_hash())
                                 params->for_each(add_xslt_param, &vdom.transformer());                                  params->for_each(add_xslt_param, &vdoc.transformer());
                         else                          else
                                 PTHROW(0, 0,                                  throw Exception(0, 0,
                                         &method_name,                                          &method_name,
                                         "transform parameters parameter must be hash");                                          "transform parameters parameter must be hash");
         }          }
   
         // source          // source
         const XalanParsedSource &parsed_source=vdom.get_parsed_source(pool, &method_name);          const XalanParsedSource &parsed_source=vdoc.get_parsed_source(pool, &method_name);
   
         // stylesheet          // stylesheet
         const String& stylesheet_file_name=params->as_string(0, "file name must not be code");          const String& stylesheet_file_name=params->as_string(0, "file name must be string");
         const String& stylesheet_filespec=r.absolute(stylesheet_file_name);          const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
         //_asm int 3;          //_asm int 3;
         Stylesheet_connection& connection=XSLT_stylesheet_manager->get_connection(stylesheet_filespec);          Stylesheet_connection& connection=XSLT_stylesheet_manager->get_connection(stylesheet_filespec);
   
         // target          // target
         XalanDocument* target=vdom.parser_liaison().createDocument();          XalanDocument* target=vdoc.parser_liaison().createDocument();
         XSLTResultTarget domResultTarget(target);  
   
         // transform          // transform
         int error=vdom.transformer().transform(          try {
                 parsed_source,                   vdoc.transformer().transform2(
                 &connection.stylesheet(),                           parsed_source, 
                 domResultTarget);                          &connection.stylesheet(true/*nocache* /), 
         connection.close();                          target);
         if(error)          }
                 PTHROW(0, 0,          catch (XSLException& e) {
                         &stylesheet_file_name,                  connection.close();
                         vdom.transformer().getLastError());                  Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch (SAXParseException& e)    {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch (SAXException& e) {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch (XMLException& e) {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch(const XalanDOMException& e)       {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
   
         // write out result          // write out result
         VXdoc& result=*new(pool) VXdoc(pool);          VXdoc& result=*new(pool) VXdoc(pool);
         result.set_document(*target);          result.set_document(*target);
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
   */
 static void _getElementById(Request& r, const String& method_name, MethodParams *params) {  static void _transform(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VXdoc& vdoc=*static_cast<VXdoc *>(r.self);          VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
         // elementId          // params
         const char *elementId=params->as_string(0, "elementID must not be code").cstr(String::UL_AS_IS);          if(params->size()>1) {
                   Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
         if(XalanElement *element=                  if(vparams.is_defined())
                 vdoc.get_document(pool, &method_name).getElementById(XalanDOMString(elementId))) {                          if(Hash *params=vparams.get_hash())
                 // write out result                                  params->for_each(add_xslt_param, &vdoc.transformer());
                 VXnode& result=*new(pool) VXnode(pool, element);                          else
                 r.write_no_lang(result);                                  throw Exception(0, 0,
                                           &method_name,
                                           "transform parameters parameter must be hash");
         }          }
 }  
   
 static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {          // source
         Pool& pool=r.pool();          XalanDocument &xalan_document=vdoc.get_document(pool, &method_name);
         VXdoc& vdoc=*static_cast<VXdoc *>(r.self);  
   
         // tagname          // stylesheet
         const char *tagname=params->as_string(0, "tagname must not be code").cstr(String::UL_AS_IS);          const String& stylesheet_file_name=params->as_string(0, "file name must be string");
           const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
           //_asm int 3;
           Stylesheet_connection& connection=stylesheet_manager->get_connection(stylesheet_filespec);
   
         VHash& result=*new(pool) VHash(pool);          // target
         if(const XalanNodeList *nodes=          XalanDocument* target=vdoc.parser_liaison().createDocument();
                 vdoc.get_document(pool, &method_name).getElementsByTagName(XalanDOMString(tagname))) {  
                 for(int i=0; i<nodes->getLength(); i++) {  
                         String& skey=*new(pool) String(pool);  
                         {  
                                 char *buf=(char *)pool.malloc(MAX_NUMBER);  
                                 snprintf(buf, MAX_NUMBER, "%d", i);  
                                 skey << buf;  
                         }  
   
                         result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));          // transform
                 }          try {
                   vdoc.transformer().transform2(
                           &xalan_document, 
                           &connection.stylesheet(true/*nocache*/), 
                           target);
           }
           catch (XSLException& e) {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch (SAXParseException& e)    {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch (SAXException& e) {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch (XMLException& e) {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
           }
           catch(const XalanDOMException& e)       {
                   connection.close();
                   Exception::provide_source(pool, &stylesheet_file_name, e);
         }          }
   
         // write out result          // write out result
           VXdoc& result=*new(pool) VXdoc(pool, target, false/*owns not*/);
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
   
 static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams *params) {  static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VXdoc& vdoc=*static_cast<VXdoc *>(r.self);          VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
   
         // namespaceURI;localName          // elementId
         const char *namespaceURI=params->as_string(0, "namespaceURI must not be code").cstr(String::UL_AS_IS);          const String& elementId=params->as_string(0, "elementID must be string");
         const char *localName=params->as_string(0, "localName must not be code").cstr(String::UL_AS_IS);  
   
         VHash& result=*new(pool) VHash(pool);  
         if(const XalanNodeList *nodes=  
                 vdoc.get_document(pool, &method_name).getElementsByTagNameNS(  
                         XalanDOMString(namespaceURI), XalanDOMString(localName))) {  
                 for(int i=0; i<nodes->getLength(); i++) {  
                         String& skey=*new(pool) String(pool);  
                         {  
                                 char *buf=(char *)pool.malloc(MAX_NUMBER);  
                                 snprintf(buf, MAX_NUMBER, "%d", i);  
                                 skey << buf;  
                         }  
   
                         result.hash().put(skey, new(pool) VXnode(pool, nodes->item(i)));          if(XalanNode *node=
                 }                  vdoc.get_document(pool, &method_name).getElementById(*pool.transcode(elementId))) {
                   // write out result
                   VXnode& result=*new(pool) VXnode(pool, node, false);
                   r.write_no_lang(result);
         }          }
   
         // write out result  
         r.write_no_lang(result);  
 }  }
   
 // constructor  // constructor
   
 MXdoc::MXdoc(Pool& apool) : MXnode(apool) {  MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
         set_name(*NEW String(pool(), XDOC_CLASS_NAME));          set_name(*NEW String(pool(), XDOC_CLASS_NAME));
   
           /// @test how to create empty type html?
   
           /// DOM1
   
           // Element createElement(in DOMString tagName) raises(DOMException);
           add_native_method("createElement", Method::CT_DYNAMIC, _createElement, 1, 1);
           // DocumentFragment createDocumentFragment(); 
           add_native_method("createDocumentFragment", Method::CT_DYNAMIC, _createDocumentFragment, 0, 0);
           // Text createTextNode(in DOMString data);
           add_native_method("createTextNode", Method::CT_DYNAMIC, _createTextNode, 1, 1);
           // Comment createComment(in DOMString data);
           add_native_method("createComment", Method::CT_DYNAMIC, _createComment, 1, 1);
           // CDATASection createCDATASection(in DOMString data) raises(DOMException);
           add_native_method("createCDATASection", Method::CT_DYNAMIC, _createCDATASection, 1, 1);
           // ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException);
           add_native_method("createProcessingInstruction", Method::CT_DYNAMIC, _createProcessingInstruction, 2, 2);
           // Attr createAttribute(in DOMString name) raises(DOMException);
           add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
           // EntityReference createEntityReference(in DOMString name) raises(DOMException);
           add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
           // NodeList getElementsByTagName(in DOMString tagname);
           /*      
                   // ^xdoc.getElementsByTagName[tagname]
                   add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
   
                   // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
                   add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
           */
   
           /// DOM2(?)
   
           // ^xdoc.getElementById[elementId]
           add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
   
           /// parser
           
         // ^xdoc.save[some.xml]          // ^xdoc.save[some.xml]
         // ^xdoc.save[some.xml;options hash]          // ^xdoc.save[some.xml;options hash]
         add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);          add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
Line 419  MXdoc::MXdoc(Pool& apool) : MXnode(apool Line 814  MXdoc::MXdoc(Pool& apool) : MXnode(apool
   
         // ^xdoc::set[<some>xml</some>]          // ^xdoc::set[<some>xml</some>]
         add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);          add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
           // ^xdoc::create{qualifiedName}
           add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1); 
   
         // ^xdoc::load[some.xml]          // ^xdoc::load[some.xml]
         add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);          add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
   
         // ^xdoc.xslt[stylesheet file_name]          // ^xdoc.transform[stylesheet file_name]
         // ^xdoc.xslt[stylesheet file_name;params hash]          // ^xdoc.transform[stylesheet file_name;params hash]
         add_native_method("xslt", Method::CT_DYNAMIC, _xslt, 1, 2);          add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
   
         // ^xdoc.getElementById[elementId]  
         add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);  
           
         // ^xdoc.getElementById[tagname]  
         add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);  
   
         // ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes  }
         add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);  
   
   void MXdoc::configure_admin(Request& r) {
 }  }
   
 // global variable  // global variable
   
 Methoded *Xdoc_class;  Methoded *Xdoc_class;
Removed from v.1.2  
changed lines
  Added in v.1.32

E-mail: