[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.108.2.19.2.12 and 1.113.2.1

version 1.108.2.19.2.12, 2003/03/25 09:34:52 version 1.113.2.1, 2003/09/24 14:32:05
Line 5 Line 5
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
 #include "classes.h"  #include "pa_config_includes.h"
   
 #ifdef XML  #ifdef XML
   
 static const char* IDENT_XDOC_C="$Date$";  static const char* IDENT_XDOC_C="$Date$";
   
   #include "gdome.h"
   #include "libxml/tree.h"
   #include "libxslt/xsltInternals.h"
   #include "libxslt/transform.h"
   #include "libxslt/xsltutils.h"
   #include "libxslt/variables.h"
   
   
 #include "pa_vmethod_frame.h"  #include "pa_vmethod_frame.h"
   
 #include "pa_stylesheet_manager.h"  #include "pa_stylesheet_manager.h"
Line 19  static const char* IDENT_XDOC_C="$Date$" Line 28  static const char* IDENT_XDOC_C="$Date$"
 #include "pa_vfile.h"  #include "pa_vfile.h"
 #include "xnode.h"  #include "xnode.h"
   
 #include "gdome.h"  
 #include "libxml/tree.h"  
 extern "C" {  
 #include "gdomecore/gdome-xml-node.h"  
 #include "gdomecore/gdome-xml-document.h"  
 };  
 #include "libxslt/xsltInternals.h"  
 #include "libxslt/transform.h"  
 #include "libxslt/xsltutils.h"  
 #include "libxslt/variables.h"  
   
 // defines  // defines
   
 #define XDOC_CLASS_NAME "xdoc"  #define XDOC_CLASS_NAME "xdoc"
Line 169  static void writeNode(Request& r, GdomeN Line 167  static void writeNode(Request& r, GdomeN
 }  }
   
 // Element createElement(in DOMString tagName) raises(DOMException);  // Element createElement(in DOMString tagName) raises(DOMException);
 static void _createElement(Request& r, MethodParams* params) {  static void _createElement(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& tagName=params->as_string(0, "tagName must be string");          const String& tagName=params.as_string(0, "tagName must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=          GdomeNode *node=
                 (GdomeNode *)gdome_doc_createElement(vdoc.get_document(),                   (GdomeNode *)gdome_doc_createElement(vdoc.get_document(), 
                 r.transcode(tagName).get(),                  r.transcode(tagName).use(),
                   &exc);
           writeNode(r, node, exc);
   }
   
   // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
   static void _createElementNS(Request& r, MethodParams& params) {
           VXdoc& vdoc=GET_SELF(r, VXdoc);
   
           // namespaceURI;localName
           const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
           const String& qualifiedName=params.as_string(1, "qualifiedName must be string");
   
           GdomeException exc;
           GdomeNode *node=
                   (GdomeNode *)gdome_doc_createElementNS(vdoc.get_document(), 
                   r.transcode(namespaceURI).use(),
                   r.transcode(qualifiedName).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
 // DocumentFragment createDocumentFragment()  // DocumentFragment createDocumentFragment()
 static void _createDocumentFragment(Request& r, MethodParams* ) {  static void _createDocumentFragment(Request& r, MethodParams&) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         GdomeException exc;          GdomeException exc;
Line 195  static void _createDocumentFragment(Requ Line 210  static void _createDocumentFragment(Requ
 }  }
   
 // Text createTextNode(in DOMString data);  // Text createTextNode(in DOMString data);
 static void _createTextNode(Request& r, MethodParams* params) {  static void _createTextNode(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& data=params->as_string(0, "data must be string");          const String& data=params.as_string(0, "data must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=(GdomeNode *)gdome_doc_createTextNode(          GdomeNode *node=(GdomeNode *)gdome_doc_createTextNode(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(data).get(),                  r.transcode(data).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
 // Comment createComment(in DOMString data)  // Comment createComment(in DOMString data)
 static void _createComment(Request& r, MethodParams* params) {  static void _createComment(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& data=params->as_string(0, "data must be string");          const String& data=params.as_string(0, "data must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=(GdomeNode *)gdome_doc_createComment(          GdomeNode *node=(GdomeNode *)gdome_doc_createComment(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(data).get(),                  r.transcode(data).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
 // CDATASection createCDATASection(in DOMString data) raises(DOMException);  // CDATASection createCDATASection(in DOMString data) raises(DOMException);
 static void _createCDATASection(Request& r, MethodParams* params) {  static void _createCDATASection(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& data=params->as_string(0, "data must be string");          const String& data=params.as_string(0, "data must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=(GdomeNode *)gdome_doc_createCDATASection(          GdomeNode *node=(GdomeNode *)gdome_doc_createCDATASection(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(data).get(),                  r.transcode(data).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
 // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);  // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
 static void _createProcessingInstruction(Request& r, MethodParams* params) {  static void _createProcessingInstruction(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& target=params->as_string(0, "data must be string");          const String& target=params.as_string(0, "data must be string");
         const String& data=params->as_string(1, "data must be string");          const String& data=params.as_string(1, "data must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=(GdomeNode *)gdome_doc_createProcessingInstruction(          GdomeNode *node=(GdomeNode *)gdome_doc_createProcessingInstruction(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(target).get(),                   r.transcode(target).use(), 
                 r.transcode(data).get(),                  r.transcode(data).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
 // Attr createAttribute(in DOMString name) raises(DOMException);  // Attr createAttribute(in DOMString name) raises(DOMException);
 static void _createAttribute(Request& r, MethodParams* params) {  static void _createAttribute(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& name=params->as_string(0, "name must be string");          const String& name=params.as_string(0, "name must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=(GdomeNode *)gdome_doc_createAttribute(          GdomeNode *node=(GdomeNode *)gdome_doc_createAttribute(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(name).get(),                  r.transcode(name).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
   // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
   static void _createAttributeNS(Request& r, MethodParams& params) {
           VXdoc& vdoc=GET_SELF(r, VXdoc);
   
           // namespaceURI;qualifiedName
           const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
           const String& qualifiedName=params.as_string(1, "name must be string");
   
           GdomeException exc;
           GdomeNode *node=(GdomeNode *)gdome_doc_createAttributeNS(
                   vdoc.get_document(),
                   r.transcode(namespaceURI).use(),
                   r.transcode(qualifiedName).use(),
                   &exc);
           writeNode(r, node, exc);
   }
   
 // EntityReference createEntityReference(in DOMString name) raises(DOMException);  // EntityReference createEntityReference(in DOMString name) raises(DOMException);
 static void _createEntityReference(Request& r, MethodParams* params) {  static void _createEntityReference(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& name=params->as_string(0, "name must be string");          const String& name=params.as_string(0, "name must be string");
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *node=(GdomeNode *)gdome_doc_createEntityReference(          GdomeNode *node=(GdomeNode *)gdome_doc_createEntityReference(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(name).get(),                  r.transcode(name).use(),
                 &exc);                  &exc);
         writeNode(r, node, exc);          writeNode(r, node, exc);
 }  }
   
 // NodeList getElementsByTagName(in DOMString name);  // NodeList getElementsByTagName(in DOMString name);
 static void _getElementsByTagName(Request& r, MethodParams* params) {  static void _getElementsByTagName(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& name=params->as_string(0, "name must be string");          const String& name=params.as_string(0, "name must be string");
   
         VHash& result=*new VHash;          VHash& result=*new VHash;
         GdomeException exc;          GdomeException exc;
         if(GdomeNodeList *nodes=          if(GdomeNodeList *nodes=
                 gdome_doc_getElementsByTagName(                  gdome_doc_getElementsByTagName(
                         vdoc.get_document(),                           vdoc.get_document(), 
                         r.transcode(name).get(),                           r.transcode(name).use(), 
                         &exc)) {                          &exc)) {
                 gulong length=gdome_nl_length(nodes, &exc);                  gulong length=gdome_nl_length(nodes, &exc);
                 for(gulong i=0; i<length; i++)                  for(gulong i=0; i<length; i++)
                         result.hash().put(                          result.hash().put(
                                 StringBody(i),                                   String::Body::Format(i), 
                                 new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));                                  new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
         } else if(exc)          } else if(exc)
                 throw Exception(0, exc);                  throw Exception(0, exc);
Line 304  static void _getElementsByTagName(Reques Line 337  static void _getElementsByTagName(Reques
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
   
 static void _getElementsByTagNameNS(Request& r, MethodParams* params) {  static void _getElementsByTagNameNS(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         // namespaceURI;localName          // namespaceURI;localName
         const String& namespaceURI=params->as_string(0, "namespaceURI must be string");          const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
         const String& localName=params->as_string(1, "localName must be string");          const String& localName=params.as_string(1, "localName must be string");
   
         GdomeException exc;          GdomeException exc;
         VHash& result=*new VHash;          VHash& result=*new VHash;
         if(GdomeNodeList *nodes=          if(GdomeNodeList *nodes=
                 gdome_doc_getElementsByTagNameNS(                  gdome_doc_getElementsByTagNameNS(
                         vdoc.get_document(),                           vdoc.get_document(), 
                         r.transcode(namespaceURI).get(),                          r.transcode(namespaceURI).use(),
                         r.transcode(localName).get(),                          r.transcode(localName).use(),
                         &exc)) {                          &exc)) {
                 gulong length=gdome_nl_length(nodes, &exc);                  gulong length=gdome_nl_length(nodes, &exc);
                 for(gulong i=0; i<length; i++)                  for(gulong i=0; i<length; i++)
                         result.hash().put(                          result.hash().put(
                                 StringBody(i),                                   String::Body::Format(i), 
                                 new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));                                  new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
         }          }
   
Line 330  static void _getElementsByTagNameNS(Requ Line 363  static void _getElementsByTagNameNS(Requ
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
   
 static void _getElementById(Request& r, MethodParams* params) {  static void _getElementById(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         // elementId          // elementId
         const String& elementId=params->as_string(0, "elementID must be string");          const String& elementId=params.as_string(0, "elementID must be string");
   
         GdomeException exc;          GdomeException exc;
         if(GdomeNode *node=(GdomeNode *)gdome_doc_getElementById(          if(GdomeNode *node=(GdomeNode *)gdome_doc_getElementById(
                 vdoc.get_document(),                  vdoc.get_document(),
                 r.transcode(elementId).get(),                  r.transcode(elementId).use(),
                 &exc)) {                  &exc)) {
                 // write out result                  // write out result
                 r.write_no_lang(*new VXnode(&r.charsets, node));                  r.write_no_lang(*new VXnode(&r.charsets, node));
Line 349  static void _getElementById(Request& r, Line 382  static void _getElementById(Request& r,
                         exc);                          exc);
 }  }
   
 static void _importNode(Request& r, MethodParams* params) {  static void _importNode(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         GdomeNode *importedNode=          GdomeNode *importedNode=
                 as_node(params, 0, "importedNode must be node");                  as_node(params, 0, "importedNode must be node");
         bool deep=          bool deep=
                 params->as_bool(1, "deep must be bool", r);                  params.as_bool(1, "deep must be bool", r);
   
         GdomeException exc;          GdomeException exc;
         GdomeNode *outputNode=gdome_doc_importNode(vdoc.get_document(),           GdomeNode *outputNode=gdome_doc_importNode(vdoc.get_document(), 
Line 372  GdomeElement *gdome_doc_createElementNS Line 405  GdomeElement *gdome_doc_createElementNS
 GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);  GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
 */  */
   
 static void _create(Request& r, MethodParams* params) {  static void _create(Request& r, MethodParams& params) {
         Charset& source_charset=r.charsets.source();          Charset& source_charset=r.charsets.source();
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         Value& param=*(*params)[params->count()-1];          Value& param=params[params.count()-1];
         GdomeDocument *document;          GdomeDocument *document;
           bool set_encoding=false;
         if(param.get_junction()) { // {<?xml?>...}          if(param.get_junction()) { // {<?xml?>...}
                 Temp_lang temp_lang(r, String::L_XML);                  Temp_lang temp_lang(r, String::L_XML);
                 const String& xml=r.process_to_string(param);                  const String& xml=r.process_to_string(param);
Line 387  static void _create(Request& r, MethodPa Line 421  static void _create(Request& r, MethodPa
                         gdome_xml_n_mkref((xmlNode *)xmlParseMemory(                          gdome_xml_n_mkref((xmlNode *)xmlParseMemory(
                                 cstr, strlen(cstr)                                  cstr, strlen(cstr)
                         ));                          ));
                   //printf("document=0x%p\n", document);
                 if(!document || xmlHaveGenericErrors()) {                  if(!document || xmlHaveGenericErrors()) {
                         GdomeException exc=0;                          GdomeException exc=0;
                         throw Exception(0, exc);                          throw Exception(0, exc);
                 }                  }
   
                   // must be last action in if, see after if}
         } else { // [name]          } else { // [name]
                 const String& qualifiedName=param.as_string();                  const String& qualifiedName=param.as_string();
   
Line 406  static void _create(Request& r, MethodPa Line 443  static void _create(Request& r, MethodPa
                         throw Exception(                          throw Exception(
                                 method_name,                                   method_name, 
                                 exc);                                  exc);
                   /// +xalan createXMLDecl ?
                 */                  */
                 document=gdome_di_createDocument (domimpl,                   document=gdome_di_createDocument (domimpl, 
                         0/*namespaceURI*/,                           0/*namespaceURI*/, 
                         r.transcode(qualifiedName).get(),                           r.transcode(qualifiedName).use(), 
                         0/*doctype*/,                           0/*doctype*/, 
                         &exc);                          &exc);
                 if(!document || exc || xmlHaveGenericErrors())                  if(!document || exc || xmlHaveGenericErrors())
                         throw Exception(0, exc);                          throw Exception(0, exc);
   
                 xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);                  set_encoding=true;
                 const char* source_charset_name=source_charset.name().cstr();                  // must be last action in if, see after if}
                 doc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));          }
           // must be first action after if}
                 /// +xalan createXMLDecl ?          // replace any previous parsed source
           {
                   vdoc.set_document(&r.charsets, document); 
                   GdomeException exc;
                   gdome_doc_unref(document, &exc);
         }          }
                   
         // URI           // URI 
         const char* URI_cstr;          const char* URI_cstr;
         const char* URI_cstr_ptr;          const char* URI_cstr_ptr;
         if(params->count()>1) { // absolute(param)          if(params.count()>1) { // absolute(param)
                 const String& URI=params->as_string(0, "URI must be string");                  const String& URI=params.as_string(0, "URI must be string");
                 URI_cstr=URI_cstr_ptr=r.absolute(URI).cstr();                  URI_cstr=URI_cstr_ptr=r.absolute(URI).cstr();
         } else // default = disk path to requested document          } else // default = disk path to requested document
                 URI_cstr=r.request_info.path_translated;                  URI_cstr=r.request_info.path_translated;
Line 434  static void _create(Request& r, MethodPa Line 476  static void _create(Request& r, MethodPa
         if(URI_cstr)          if(URI_cstr)
                 doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));                  doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
   
         // replace any previous parsed source          if(set_encoding) {
         vdoc.set_document(&r.charsets, document);                  const char* source_charset_name=source_charset.NAME().cstr();
                   doc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
           }
 }  }
   
 static void _load(Request& r, MethodParams* params) {  static void _load(Request& r, MethodParams& params) {
         Charset& source_charset=r.charsets.source();  
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         // filespec          // filespec
         const String& file_name=params->as_string(0, "uri must be string");          const String& file_name=params.as_string(0, "uri must be string");
         const String& uri=r.absolute(file_name);          const String& uri=r.absolute(file_name);
   
         File_read_result file=file_read(source_charset, uri, false/*not text*/,          File_read_result file=file_read(r.charsets, uri, false/*not text*/,
                 params->count()>1?params->as_no_junction(1, "additional params must be hash")                  params.count()>1?params.as_no_junction(1, "additional params must be hash")
                         .get_hash()                          .get_hash()
                         :0);                          :0);
   
Line 457  static void _load(Request& r, MethodPara Line 500  static void _load(Request& r, MethodPara
                 GdomeException exc=0;                  GdomeException exc=0;
                 throw Exception(&uri, exc);                  throw Exception(&uri, exc);
         }          }
           // must be first action after if}
           // replace any previous parsed source
           {
                   vdoc.set_document(&r.charsets, document); 
                   GdomeException exc;
                   gdome_doc_unref(document, &exc);
           }
   
         const char* URI_cstr=uri.cstr();          const char* URI_cstr=uri.cstr();
         xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);          xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);
         if(URI_cstr)          if(URI_cstr)
                 doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));                  doc->URL=r.charsets.source().transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
   
         // replace any previous parsed source  
         vdoc.set_document(&r.charsets, document);  
 }  }
   
 static void param_option_over_output_option(  static void param_option_over_output_option(
                                             HashStringValue& param_options, const char* option_name,                                              HashStringValue& param_options, const char* option_name,
                                             const String*& output_option) {                                              const String*& output_option) {
         if(Value* value=param_options.get(StringBody(option_name)))          if(Value* value=param_options.get(String::Body(option_name)))
                 output_option=&value->as_string();                  output_option=&value->as_string();
 }  }
 static void param_option_over_output_option(  static void param_option_over_output_option(
                                             HashStringValue& param_options, const char* option_name,                                              HashStringValue& param_options, const char* option_name,
                                             bool& output_option) {                                              bool& output_option) {
         if(Value* value=param_options.get(StringBody(option_name))) {          if(Value* value=param_options.get(String::Body(option_name))) {
                 const String& s=value->as_string();                  const String& s=value->as_string();
                 if(s=="yes")                  if(s=="yes")
                         output_option=true;                          output_option=true;
Line 490  static void param_option_over_output_opt Line 539  static void param_option_over_output_opt
   
 /// @test valid_options check  /// @test valid_options check
 static void prepare_output_options(Request& r,  static void prepare_output_options(Request& r,
                                    MethodParams* params, int index,                                     MethodParams& params, size_t index,
                                    VXdoc::Output_options& oo) {                                     VXdoc::Output_options& oo) {
 /*  /*
 <xsl:output  <xsl:output
Line 507  static void prepare_output_options(Reque Line 556  static void prepare_output_options(Reque
 */  */
   
         // configuring with options from parameter...          // configuring with options from parameter...
         if(params->count()>index) {          if(params.count()>index) {
                 Value& voptions=params->as_no_junction(index, "options must be string");                  Value& voptions=params.as_no_junction(index, "options must be string");
                 if(voptions.is_defined()) {                  if(voptions.is_defined()) {
                         if(HashStringValue *options=voptions.get_hash()) {                          if(HashStringValue *options=voptions.get_hash()) {
                                 // $.method[xml|html|text]                                  // $.method[xml|html|text]
                                 if(Value* vmethod=options->get(StringBody(XDOC_OUTPUT_METHOD_OPTION_NAME)))                                  if(Value* vmethod=options->get(String::Body(XDOC_OUTPUT_METHOD_OPTION_NAME)))
                                         oo.method=&vmethod->as_string();                                          oo.method=&vmethod->as_string();
   
                                 // $.version[1.0]                                  // $.version[1.0]
Line 537  static void prepare_output_options(Reque Line 586  static void prepare_output_options(Reque
   
         // default encoding from pool          // default encoding from pool
         if(!oo.encoding)          if(!oo.encoding)
                 oo.encoding=&r.charsets.source().name();                  oo.encoding=new String(r.charsets.source().NAME(), String::L_TAINTED);
         // default method=xml          // default method=xml
         if(!oo.method)          if(!oo.method)
                 oo.method=new String(XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);                  oo.method=new String(XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);
Line 557  struct Xdoc2buf_result { Line 606  struct Xdoc2buf_result {
         size_t length;          size_t length;
 };  };
 static Xdoc2buf_result xdoc2buf(Request& r, VXdoc& vdoc,   static Xdoc2buf_result xdoc2buf(Request& r, VXdoc& vdoc, 
                                          MethodParams* params, int index,                                           MethodParams& params, int index,
                                          VXdoc::Output_options& oo,                                           VXdoc::Output_options& oo,
                                          const String* file_spec) {                                           const String* file_spec) {
         Xdoc2buf_result result;          Xdoc2buf_result result;
Line 585  static Xdoc2buf_result xdoc2buf(Request& Line 634  static Xdoc2buf_result xdoc2buf(Request&
                         "xsltNewStylesheet failed");                          "xsltNewStylesheet failed");
   
         #define OOS2STYLE(name) \          #define OOS2STYLE(name) \
                 stylesheet->name=oo.name?BAD_CAST g_strdup(r.transcode(*oo.name)->str):0                  stylesheet->name=oo.name?BAD_CAST xmlMemStrdup(r.transcode(*oo.name)->str):0
         #define OOE2STYLE(name) \          #define OOE2STYLE(name) \
                 stylesheet->name=oo.name                  stylesheet->name=oo.name
   
Line 614  static Xdoc2buf_result xdoc2buf(Request& Line 663  static Xdoc2buf_result xdoc2buf(Request&
                 gnome_length=outputBuffer->buffer->use;                  gnome_length=outputBuffer->buffer->use;
                 gnome_str=(char *)outputBuffer->buffer->content;                  gnome_str=(char *)outputBuffer->buffer->content;
         }          }
   
         if(file_spec)          if(file_spec)
                 file_write(*file_spec,                  file_write(*file_spec,
                         gnome_str, gnome_length,                           gnome_str, gnome_length, 
Line 626  static Xdoc2buf_result xdoc2buf(Request& Line 676  static Xdoc2buf_result xdoc2buf(Request&
         return result;          return result;
 }  }
   
 static void _file(Request& r, MethodParams* params) {  static void _file(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
         VXdoc::Output_options oo(vdoc.output_options);          VXdoc::Output_options oo(vdoc.output_options);
         Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0,           Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0, 
Line 642  static void _file(Request& r, MethodPara Line 692  static void _file(Request& r, MethodPara
                 value_name,                   value_name, 
                 new VString(*oo.mediaType));                  new VString(*oo.mediaType));
         vhcontent_type.hash().put(          vhcontent_type.hash().put(
                 StringBody("charset"),                   String::Body("charset"), 
                 new VString(*oo.encoding));                  new VString(*oo.encoding));
   
         vfile.set(false/*tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length,           vfile.set(false/*tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length, 
Line 650  static void _file(Request& r, MethodPara Line 700  static void _file(Request& r, MethodPara
         r.write_no_lang(vfile);          r.write_no_lang(vfile);
 }  }
   
 static void _save(Request& r, MethodParams* params) {  static void _save(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         const String& file_spec=r.absolute(params->as_string(0, "file name must be string"));          const String& file_spec=r.absolute(params.as_string(0, "file name must be string"));
                   
         VXdoc::Output_options oo(vdoc.output_options);          VXdoc::Output_options oo(vdoc.output_options);
         xdoc2buf(r, vdoc, params, 1,           xdoc2buf(r, vdoc, params, 1, 
Line 661  static void _save(Request& r, MethodPara Line 711  static void _save(Request& r, MethodPara
                 &file_spec);                  &file_spec);
 }  }
   
 static void _string(Request& r, MethodParams* params) {  static void _string(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
         VXdoc::Output_options oo(vdoc.output_options);          VXdoc::Output_options oo(vdoc.output_options);
         Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0,           Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0, 
Line 674  static void _string(Request& r, MethodPa Line 724  static void _string(Request& r, MethodPa
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Add_xslt_param_info {  struct Add_xslt_param_info {
         Request* r;          Request* r;
           Array<GdomeDOMString_auto_ptr>* strings;
         const char** current_transform_param;          const char** current_transform_param;
 };  };
 #endif  #endif
Line 681  static void add_xslt_param( Line 732  static void add_xslt_param(
                            HashStringValue::key_type attribute,                              HashStringValue::key_type attribute, 
                            HashStringValue::value_type meaning,                              HashStringValue::value_type meaning, 
                            Add_xslt_param_info* info) {                             Add_xslt_param_info* info) {
         *info->current_transform_param++=info->r->transcode(attribute)->str;          GdomeDOMString_auto_ptr s;
         *info->current_transform_param++=info->r->transcode(meaning->as_string())->str;          *info->current_transform_param++=(s=info->r->transcode(attribute))->str; *info->strings+=s;
           *info->current_transform_param++=(s=info->r->transcode(meaning->as_string()))->str; *info->strings+=s;
 }  }
 static VXdoc& _transform(Request& r, const String* stylesheet_source,   static VXdoc& _transform(Request& r, const String* stylesheet_source, 
                                                    VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params) {                                                     VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params) {
Line 690  static VXdoc& _transform(Request& r, con Line 742  static VXdoc& _transform(Request& r, con
         xsltTransformContext_auto_ptr transformContext(          xsltTransformContext_auto_ptr transformContext(
                 xsltNewTransformContext(stylesheet, document));                  xsltNewTransformContext(stylesheet, document));
         // make params literal          // make params literal
     if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext          if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
                 transformContext->globalVars = xmlHashCreate(20);                  transformContext->globalVars = xmlHashCreate(20);
         xsltQuoteUserParams(transformContext.get(), transform_params);          xsltQuoteUserParams(transformContext.get(), transform_params);
         // do transform          // do transform
Line 745  static VXdoc& _transform(Request& r, con Line 797  static VXdoc& _transform(Request& r, con
         // return          // return
         return result;          return result;
 }  }
 static void _transform(Request& r, MethodParams* params) {  static void _transform(Request& r, MethodParams& params) {
         VXdoc& vdoc=GET_SELF(r, VXdoc);          VXdoc& vdoc=GET_SELF(r, VXdoc);
   
         // params          // params
         Array<GdomeDOMString_auto_ptr> transform_strings;          Array<GdomeDOMString_auto_ptr> transform_strings;
         const char** transform_params;          const char** transform_params=0;
         if(params->count()>1) {          if(params.count()>1) {
                 Value& vparams=params->as_no_junction(1, "transform parameters must be hash");                  Value& vparams=params.as_no_junction(1, "transform parameters must be hash");
                 if(!vparams.is_string())                  if(!vparams.is_string())
                         if(HashStringValue* params=vparams.get_hash()) {                          if(HashStringValue* hash=vparams.get_hash()) {
                                 transform_params=new(UseGC) const char*[params->count()*2+1];                                  transform_params=new(UseGC) const char*[hash->count()*2+1];
                                 Add_xslt_param_info info={                                  Add_xslt_param_info info={
                                         &r,                                           &r, 
                                           &transform_strings,
                                         transform_params                                          transform_params
                                 };                                  };
                                 params->for_each(add_xslt_param, &info);                                  hash->for_each(add_xslt_param, &info);
                                 transform_params[params->count()*2]=0;                                                            transform_params[hash->count()*2]=0;                            
                         } else                          } else
                                 throw Exception("parser.runtime",                                  throw Exception("parser.runtime",
                                         0,                                          0,
Line 769  static void _transform(Request& r, Metho Line 822  static void _transform(Request& r, Metho
         }          }
   
         VXdoc* result;          VXdoc* result;
         Value* vmaybe_xdoc=(*params)[0];          if(Value *vxdoc=params[0].as(VXDOC_TYPE, false)) { // stylesheet (xdoc)
         if(Value *vxdoc=vmaybe_xdoc->as(VXDOC_TYPE, false)) { // stylesheet (xdoc)  
                 xmlDoc *document=gdome_xml_doc_get_xmlDoc(                  xmlDoc *document=gdome_xml_doc_get_xmlDoc(
                         static_cast<VXdoc *>(vxdoc)->get_document());                          static_cast<VXdoc *>(vxdoc)->get_document());
                 // compile xdoc stylesheet                  // compile xdoc stylesheet
Line 794  static void _transform(Request& r, Metho Line 846  static void _transform(Request& r, Metho
         } else { // stylesheet (file name)          } else { // stylesheet (file name)
                 // extablish stylesheet connection                  // extablish stylesheet connection
                 const String& stylesheet_filespec=                  const String& stylesheet_filespec=
                         r.absolute(params->as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));                          r.absolute(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
                 Stylesheet_connection_ptr connection=stylesheet_manager.get_connection(stylesheet_filespec);                  Stylesheet_connection_ptr connection=stylesheet_manager.get_connection(stylesheet_filespec);
   
                 // load and compile file to stylesheet [or get cached if any]                  // load and compile file to stylesheet [or get cached if any]
Line 841  MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, Line 893  MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,
     // Node (in Node importedNode, in boolean deep) raises(DOMException)      // Node (in Node importedNode, in boolean deep) raises(DOMException)
         add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);          add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);
   
           // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
           add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);
   
           // Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
           add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);
   
         // NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName);          // NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName);
         add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);          add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
   
Line 879  void MXdoc::configure_admin(Request& r) Line 937  void MXdoc::configure_admin(Request& r)
   
 # else  # else
   
   #include "classes.h"
   
 // global variable  // global variable
   
 DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive  DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive
Removed from v.1.108.2.19.2.12  
changed lines
  Added in v.1.113.2.1

E-mail: