xmlparser.pkg

Go to the documentation of this file.

// -- processed by [filterPKG] --
/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2009 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

/**************************************************
 XML parser library
 
 Version: 1.0
 Author: Bastien BOURINEAU / I-maginer
 Last update: 03.03.2009
 
**************************************************/

var iXMLdebug=0;

// - Structure of XML file -
struct XMLfile{

  XMLpath (S);
  XMLtype (S);
  XMLmarks ([XMLmark r1]);
  XMLidref (I
  
);
};
typedef struct mkXMLfile XMLfile;


// - Structure of XML marks -
struct XMLmark{

  XMLid (I);
  XMLvalue (S);
  XMLparams ([[S S] r1]);
  XMLdata (S);
  XMLfather (XMLmark);
  XMLsons ([XMLmark r1]
  
);
};
typedef struct mkXMLmark XMLmark;


XMLlcat(p, q){
if p==nil
  then
    q
  else let p -> [h nxt] in
    h::XMLlcat nxt q;
}


// since scol tuple management are "special" we add to copy all values
XMLcopyParams(l){
let nil -> newl in
  (
    let sizelist l -> size in
    while size > 0 do
    (
      let nth_list l (size -1) -> [n p] in
        set newl = [n p]::newl;
        
      set size = size -1;
    );
    newl;
  );
}


XMLremove_mark_list(l, elt){
if l==nil
  then
    nil
  else
    if (hd l) == elt
    then
      tl l
    else
      (hd l)::XMLremove_mark_list tl l elt;
}


XMLgetShortFloatToString(float){
if (absf float) >. (itof (ftoi absf float)) then (ftoa float) else (itoa (ftoi float));
}


// <![CDATA[ and ends with ]]>
//ctoa 60 // <
//ctoa 62 // >
//ctoa 47 // /


XMLgetBoolParam(markstr, name){
let switchstr markstr.XMLparams name -> str in
  if (!strcmpi strtrim str "ON") || (!strcmpi strtrim str "true") || (!strcmpi strtrim str "yes") || ((atoi str) == 1) then 1 else 0;
}


XMLgetBoolString(b){
if b then "true" else "false";
}


XMLgetData(markstr){
markstr.XMLdata;
}


XMLsetData(markstr, data){
set markstr.XMLdata = data;
}


XMLgetParam(markstr, name){
switchstr markstr.XMLparams name;
}


XMLsetParam(markstr, name, val){
let 0 -> found in
  (
    let sizelist markstr.XMLparams -> size in
    let 0 -> i in
    while (i < size) && !found do
    (
      let nth_list markstr.XMLparams i -> param in
      let param -> [pname pval] in
      if strcmp pname name then nil else
      (
        mutate param <- [_ val];
        set found = 1;
      );
      
      set i = i + 1;
    );
    
    // add the new param if not exist
    if found then nil else
      set markstr.XMLparams = XMLlcat markstr.XMLparams [name val]::nil;
  );
  0;
}


// TODO test also if the current mark have the same mark name with <mark />
XMLgetEndMarkPos(fcont, iemark, sncmark){
let iemark - 1 -> i in
  let iemark - 1 -> i2 in
  let nil -> find in
  let 1 -> nbfind in
  (
    while (i != nil) && (find == nil) do
    (
      let strfindi strcatn (ctoa 60)::sncmark::" "::nil fcont i + 1 -> ismark in
      //let if !strcmpi strcatn (ctoa 47)::(ctoa 62)::nil (substr fcont i + 1 2) then 1 else 0 -> noendmark in
      let strfindi strcatn (ctoa 60)::(ctoa 47)::sncmark::(ctoa 62)::nil fcont i2 + 1 -> iclmark in           
      (
        if (((ismark != nil) && (ismark < iclmark))) then // && !noendmark then
          set nbfind = nbfind + 1
        else
          set find = iemark - 1;
        
        set i = ismark;
        set i2 = iclmark;
      );
    );
    
    while (nbfind != 0) do
    (
      let strfindi strcatn (ctoa 60)::(ctoa 47)::sncmark::(ctoa 62)::nil fcont find + 1 -> iclmark in
      (
        set find = iclmark;
        set nbfind = nbfind - 1;
      );
    );
    find;
  );
}


XMLgetMark(xmlfilestr, father, fcont, spos){
let strfind ctoa 60 fcont spos -> ismark in
  let strfind ctoa 62 fcont ismark -> iemark in
  let substr fcont (ismark + 1) ((iemark - ismark) - 1) -> snmark in
  let strfind " " snmark 0 -> haveparam in
  let if haveparam != nil then substr snmark 0 haveparam else snmark -> sncmark in
  let if !strcmpi strcatn (ctoa 47)::(ctoa 62)::nil (substr fcont (iemark -1) 2) then 1 else 0 -> noendmark in
  let if noendmark then (iemark + 1) else XMLgetEndMarkPos fcont iemark sncmark -> iclmark in
  let substr fcont (iemark + 1) ((iclmark - iemark) - 1) -> mcont in
  let mkXMLmark [(set xmlfilestr.XMLidref = xmlfilestr.XMLidref + 1) sncmark nil nil father nil] -> markstr in
  (
    if haveparam == nil then nil else
    (
      if !iXMLdebug then nil else
        _fooS strcat "XMLPARSER DEBUG : Mark found > " sncmark;

      while haveparam != nil do
      (
        let strfind "=" snmark haveparam -> ppos in
        let substr snmark (ppos + 1) 1 -> psep in
        let substr snmark (haveparam + 1) ((ppos - haveparam) - 1) -> pname in
        let strfind psep snmark ppos -> sppos in
        if sppos == nil then
        (
          set haveparam = nil;
        )
        else
        let strfind psep snmark (sppos + 1) -> eppos in
        (
          let substr snmark (sppos + 1) ((eppos - sppos) - 1) -> pval in
          (
            set markstr.XMLparams = XMLlcat markstr.XMLparams [pname (webtostr pval)]::nil;
            if !iXMLdebug then nil else
            (
              _fooS strcat "XMLPARSER DEBUG : Mark param name > " pname;
              _fooS strcat "XMLPARSER DEBUG : Mark param value > " (webtostr pval);
            );
            set haveparam = strfind " " snmark eppos + 1;
          );
        );
      );
    );
    
    if (strfind "<![CDATA[" mcont 0 == nil) then nil else
    let strfind "]]>" mcont 0 -> edata in
    (
      let substr mcont 9 ((edata - 8) - 1) -> data in
      set markstr.XMLdata = if (strlen data) == 0 then nil else data;
      set mcont = substr mcont edata + 3 ((strlen mcont) - (edata + 3));
      if !iXMLdebug then nil else
        _fooS strcat "XMLPARSER DEBUG : Mark newdata > " mcont;
    );
    
    let strfind ctoa 60 mcont 0 -> i in
    if (i != nil) then
    (
      while i != nil do
      (
        let (XMLgetMark xmlfilestr markstr mcont i) -> [nmark epos] in
        (
          set markstr.XMLsons = XMLlcat markstr.XMLsons nmark::nil;
          set i = strfind ctoa 60 mcont epos + 1;
        );       
      );
      0;
    )
    else if markstr.XMLdata != nil then nil else
    (
      set markstr.XMLdata = if (strlen mcont) == 0 then nil else mcont;
      0;
    );
    if !iXMLdebug then nil else
      _fooS strcatn "XMLPARSER DEBUG : Mark value > "::sncmark::" > "::markstr.XMLdata::nil;
    
    [markstr (if noendmark then iclmark else (iclmark + (strlen (strcatn (ctoa 60)::(ctoa 47)::sncmark::(ctoa 62)::nil))))];
  );
}


XMLparse(xmlfilestr, fcont){
let nil -> lmarkstr in
  let strfind ctoa 60 fcont 0 -> i in
  if (i != nil) then
  (
    while i != nil do
    (
      let (XMLgetMark xmlfilestr nil fcont i) -> [nmark epos] in
      (
        set lmarkstr = XMLlcat lmarkstr nmark::nil;
        set i = strfind ctoa 60 fcont epos + 1;
      );
    );
    lmarkstr;
  )
  else
    lmarkstr;
}


XMLcountFathers(markstr){
let 0 -> nb in
  (
    while markstr.XMLfather != nil do
    (
      set markstr = markstr.XMLfather;
      set nb = nb + 1;
    );
    nb;
  );
}


XMLgetTabs(markstr){
let "" -> tabs in
  (
    let XMLcountFathers markstr -> nb in
    let 0 -> i in
    while i < nb do
    (
      set tabs = strcat tabs (ctoa 9);
      
      set i = i + 1;
    );
    tabs;
  );
}


XMLgetMarksWithIndex(markstr){
let nil -> ncont in
  (
    set ncont = strcatn (ctoa 10)::(XMLgetTabs markstr)::"<"::markstr.XMLvalue::nil;
    set ncont = strcatn ncont::" "::"markindex"::"=\""::(itoa markstr.XMLid)::"\""::nil;
    
    let sizelist markstr.XMLparams -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLparams i -> [pname pval] in
        set ncont = strcatn ncont::" "::pname::"=\""::(strtoweb pval)::"\""::nil;

      set i = i + 1;
    );
    
    if (markstr.XMLdata == nil) && (markstr.XMLsons == nil) then
      set ncont = strcatn ncont::" />"::nil
    else if ((strfindi (ctoa 60) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 62) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 38) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 224) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 225) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 226) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 227) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 228) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 229) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 230) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 231) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 232) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 233) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 234) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 235) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 244) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 251) markstr.XMLdata 0) == nil)
    then
      set ncont = strcatn ncont::">"::markstr.XMLdata::nil
    else
      set ncont = strcatn ncont::"><![CDATA["::markstr.XMLdata::"]]>"::nil;
    
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
        set ncont = strcat ncont XMLgetMarksWithIndex mark;

      set i = i + 1;
    );
    
    if (markstr.XMLdata == nil) && (markstr.XMLsons == nil) then
      ncont
    else if markstr.XMLdata != nil then
      set ncont = strcatn ncont::"</"::markstr.XMLvalue::">"::nil
    else
      set ncont = strcatn ncont::(ctoa 10)::(XMLgetTabs markstr)::"</"::markstr.XMLvalue::">"::nil;
  );
}


XMLgetMarks(markstr){
let nil -> ncont in
  (
    set ncont = strcatn (ctoa 10)::(XMLgetTabs markstr)::"<"::markstr.XMLvalue::nil;
    
    let sizelist markstr.XMLparams -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLparams i -> [pname pval] in
        set ncont = strcatn ncont::" "::pname::"=\""::(strtoweb pval)::"\""::nil;

      set i = i + 1;
    );
    
    if (markstr.XMLdata == nil) && (markstr.XMLsons == nil) then
      set ncont = strcatn ncont::" />"::nil
    else if ((strfindi (ctoa 60) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 62) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 38) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 224) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 225) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 226) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 227) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 228) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 229) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 230) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 231) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 232) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 233) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 234) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 235) markstr.XMLdata 0) == nil)
    && ((strfindi (ctoa 244) markstr.XMLdata 0) == nil) && ((strfindi (ctoa 251) markstr.XMLdata 0) == nil)
    then
      set ncont = strcatn ncont::">"::markstr.XMLdata::nil
    else
      set ncont = strcatn ncont::"><![CDATA["::markstr.XMLdata::"]]>"::nil;
    
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
        set ncont = strcat ncont XMLgetMarks mark;

      set i = i + 1;
    );
    
    if (markstr.XMLdata == nil) && (markstr.XMLsons == nil) then
      ncont
    else if markstr.XMLdata != nil then
      set ncont = strcatn ncont::"</"::markstr.XMLvalue::">"::nil
    else
      set ncont = strcatn ncont::(ctoa 10)::(XMLgetTabs markstr)::"</"::markstr.XMLvalue::">"::nil;
  );
}


XMLaddMarkParam(markstr, paramname, value){
set markstr.XMLparams = XMLlcat markstr.XMLparams [paramname value]::nil;
  markstr;
}


XMLaddMark(xmlfilestr, value, father, params, data){
let mkXMLmark [(set xmlfilestr.XMLidref = xmlfilestr.XMLidref + 1) value params data father nil] -> markstr in
  (
    if father == nil then
      set xmlfilestr.XMLmarks = XMLlcat xmlfilestr.XMLmarks markstr::nil
    else
      set father.XMLsons = XMLlcat father.XMLsons markstr::nil;
      
    markstr;
  );
}


XMLcopyMark(xmlfilestr, srcmarkstr, father){
let srcmarkstr.XMLvalue -> value in
  let XMLcopyParams srcmarkstr.XMLparams -> params in
  let srcmarkstr.XMLdata -> data in
  let mkXMLmark [(set xmlfilestr.XMLidref = xmlfilestr.XMLidref + 1) value params data father nil] -> markstr in
  (
    if father == nil then
      set xmlfilestr.XMLmarks = XMLlcat xmlfilestr.XMLmarks markstr::nil
    else
      set father.XMLsons = XMLlcat father.XMLsons markstr::nil;
    
    let sizelist srcmarkstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list srcmarkstr.XMLsons i -> son in
        XMLcopyMark xmlfilestr son markstr;
      
      set i = i + 1;
    );

    markstr;
  );
}


XMLdelMark(xmlfilestr, markstr){
if markstr.XMLfather == nil then
    set xmlfilestr.XMLmarks = XMLremove_mark_list xmlfilestr.XMLmarks markstr
  else
    set markstr.XMLfather.XMLsons = XMLremove_mark_list markstr.XMLfather.XMLsons markstr;
  0;
}


XMLmoveMark(xmlfilestr, markstr, fatherstr){
if markstr.XMLfather == fatherstr then nil else
  (    
    if markstr.XMLfather == nil then
      set xmlfilestr.XMLmarks = XMLremove_mark_list xmlfilestr.XMLmarks markstr
    else
      set markstr.XMLfather.XMLsons = XMLremove_mark_list markstr.XMLfather.XMLsons markstr;    
    
    set markstr.XMLfather = fatherstr;
    
    if markstr.XMLfather == nil then
      set xmlfilestr.XMLmarks = XMLlcat xmlfilestr.XMLmarks markstr::nil
    else
      set markstr.XMLfather.XMLsons = XMLlcat markstr.XMLfather.XMLsons markstr::nil;
  ); 
  0;
}


XMLgetMarkByIdFromMark(markstr, id){
let nil -> fmark in
  (
    if markstr.XMLid == id then
      markstr
    else
    (
      let sizelist markstr.XMLsons -> size in
      let 0 -> i in
      while i < size && fmark == nil do
      (
        let nth_list markstr.XMLsons i -> mark in
          set fmark = XMLgetMarkByIdFromMark mark id;
        
        set i = i + 1;
      );
      fmark
    );
  );
}


XMLgetMarkById(xmlfilestr, id){
let nil -> fmark in
  (
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set fmark = XMLgetMarkByIdFromMark mark id;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarkByValueFromMark(markstr, value){
let nil -> fmark in
  (
    if !strcmpi markstr.XMLvalue value then
      markstr
    else
    (
      let sizelist markstr.XMLsons -> size in
      let 0 -> i in
      while i < size && fmark == nil do
      (
        let nth_list markstr.XMLsons i -> mark in
          set fmark = XMLgetMarkByValueFromMark mark value;
        
        set i = i + 1;
      );
      fmark
    );
  );
}


XMLgetMarkId(markstr){
markstr.XMLid;
}


XMLgetMarkByValueFromMarkSons(markstr, value){
let nil -> fmark in
  (
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list markstr.XMLsons i -> mark in
      if !strcmpi mark.XMLvalue value then
        set fmark = mark
      else nil;
      
      set i = i + 1;
    );
    fmark
  );
}


XMLgetMarkByValue(xmlfilestr, value){
let nil -> fmark in
  (
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set fmark = XMLgetMarkByValueFromMark mark value;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarksByValueFromMark(markstr, value){
let nil -> fmark in
  (
    if !strcmpi markstr.XMLvalue value then
      set fmark = XMLlcat fmark markstr::nil
    else nil;
    
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
        set fmark = XMLlcat fmark (XMLgetMarksByValueFromMark mark value);
      
      set i = i + 1;
    );
    fmark
  );
}
  

XMLgetMarksByValueFromMarkSons(markstr, value){
let nil -> fmark in
  (   
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
      if !strcmpi mark.XMLvalue value then
        set fmark = XMLlcat fmark mark::nil
      else nil;
      
      set i = i + 1;
    );
    fmark
  );
}


XMLgetMarksDataByValueFromMark(markstr, value){
let nil -> ldata in
  (
    if !strcmpi markstr.XMLvalue value then
      set ldata = XMLlcat ldata markstr.XMLdata::nil
    else nil;
    
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
      let (XMLgetMarksDataByValueFromMark mark value) -> fmarkstr in
        set ldata = XMLlcat ldata fmarkstr;
      
      set i = i + 1;
    );
    ldata
  );
}


XMLgetMarksDataByValueFromMarkSons(markstr, value){
let nil -> ldata in
  (
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
      if !strcmpi mark.XMLvalue value then
        set ldata = XMLlcat ldata mark.XMLdata::nil
      else nil;
      
      set i = i + 1;
    );
    ldata
  );
}


XMLgetMarksParamByValueFromMarkSons(markstr, value, param){
let nil -> ldata in
  (
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
      if !strcmpi mark.XMLvalue value then
        set ldata = XMLlcat ldata (XMLgetParam mark param)::nil
      else nil;
      
      set i = i + 1;
    );
    ldata
  );
}


XMLgetMarksByValue(xmlfilestr, value){
let nil -> fmark in
  (
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set fmark = XMLlcat fmark (XMLgetMarksByValueFromMark mark value);
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarksParamValueByParamFromMark(markstr, param){
let nil -> fparams in
  (
    let XMLgetParam markstr param -> ep in
    if ep != nil then
      set fparams = XMLlcat fparams ep::nil
    else nil;
    
    let sizelist markstr.XMLsons -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list markstr.XMLsons i -> mark in
        set fparams = XMLlcat fparams (XMLgetMarksParamValueByParamFromMark mark param);
      
      set i = i + 1;
    );
    fparams
  );
}


XMLgetMarksParamValueByValueAndParamFromMarkSons(markstr, value, param){
let nil -> fparams in
  let XMLgetMarksByValueFromMarkSons markstr value -> lmark in
  (
    let sizelist lmark -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lmark i -> mark in
      let XMLgetParam mark param -> ep in
      if ep == nil then nil else
        set fparams = XMLlcat fparams ep::nil;
      
      set i = i + 1;
    );
    fparams
  );
}


XMLgetMarksParamValueByValueAndParamFromMark(markstr, value, param){
let nil -> fparams in
  let XMLgetMarksByValueFromMark markstr value -> lmark in
  (
    let sizelist lmark -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lmark i -> mark in
      let XMLgetParam mark param -> ep in
      if ep == nil then nil else
        set fparams = XMLlcat fparams ep::nil;
      
      set i = i + 1;
    );
    fparams
  );
}


XMLgetMarksParamValueByParam(xmlfilestr, param){
let nil -> fparams in
  (
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set fparams = XMLlcat fparams (XMLgetMarksParamValueByParamFromMark mark param);
      
      set i = i + 1;
    );
    fparams;
  );
}


XMLgetMarkByParamValueFromMark(markstr, param, value){
let nil -> fmark in
  let XMLgetParam markstr param -> pval in
  (
    if (!strcmp value pval) then
      markstr
    else
    (
      let sizelist markstr.XMLsons -> size in
      let 0 -> i in
      while i < size && fmark == nil do
      (
        let nth_list markstr.XMLsons i -> mark in
          set fmark = XMLgetMarkByParamValueFromMark mark param value;
        
        set i = i + 1;
      );
      fmark
    );
  );
}


XMLgetMarkByParamValue(xmlfilestr, param, value){
let nil -> fmark in
  (
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set fmark = XMLgetMarkByParamValueFromMark mark param value;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarkByValueAndParamValue(xmlfilestr, markval, param, value){
let XMLgetMarksByValue xmlfilestr markval -> lmarks in
  let nil -> fmark in
  (
    let sizelist lmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list lmarks i -> mark in
      let XMLgetParam mark param -> pval in
      if (!strcmp value pval) then
        set fmark = mark
      else nil;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarksByValueAndParamValue(xmlfilestr, markval, param, value){
let XMLgetMarksByValue xmlfilestr markval -> lmarks in
  let nil -> fmark in
  (
    let sizelist lmarks -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lmarks i -> mark in
      let XMLgetParam mark param -> pval in
      if (!strcmp value pval) then
        set fmark = mark::fmark
      else nil;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarksByValueAndListParamValue(xmlfilestr, markval, lp){
let XMLgetMarksByValue xmlfilestr markval -> lmarks in
  let nil -> fmark in
  (
    let sizelist lmarks -> size in
    let sizelist lp -> size2 in
    let 0 -> i in
    while i < size do
    (
      let nth_list lmarks i -> mark in
      let 0 -> i2 in
      let 0 -> ret in
      (
        while i2 < size2 do
        (
          let nth_list lp i2 -> [param value] in
          let XMLgetParam mark param -> pval in
          if (!strcmp value pval) then
            set ret = ret + 1
          else nil;
          
          set i2 = i2 + 1;
        );
        
        if ret < size2 then nil else
          set fmark = mark::fmark
      );
       
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarkByValueAndParamValueFromMark(markstr, markval, param, value){
let XMLgetMarksByValueFromMark markstr markval -> lmarks in
  let nil -> fmark in
  (
    let sizelist lmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list lmarks i -> mark in
      let XMLgetParam mark param -> pval in
      if (!strcmp value pval) then
        set fmark = mark
      else nil;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLgetMarkByValueAndParamValueFromMarkSons(markstr, markval, param, value){
let XMLgetMarksByValueFromMarkSons markstr markval -> lmarks in
  let nil -> fmark in
  (
    let sizelist lmarks -> size in
    let 0 -> i in
    while i < size && fmark == nil do
    (
      let nth_list lmarks i -> mark in
      let XMLgetParam mark param -> pval in
      if (!strcmp value pval) then
        set fmark = mark
      else nil;
      
      set i = i + 1;
    );
    fmark;
  );
}


XMLserializeFromMark(markstr){
XMLgetMarks markstr;
}


XMLserializeWithIndexFromMark(markstr){
XMLgetMarksWithIndex markstr;
}


XMLserializeWithIndex(xmlfilestr){
let nil -> ncont in
  (
    if xmlfilestr.XMLtype == nil then nil else
      set ncont = strcatn "<?xml"::xmlfilestr.XMLtype::"?>"::nil;
    
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set ncont = strcat ncont XMLgetMarksWithIndex mark;
      
      set i = i + 1;
    );
    
    ncont;
  );
}


XMLserialize(xmlfilestr){
let nil -> ncont in
  (
    if xmlfilestr.XMLtype == nil then nil else
      set ncont = strcatn "<?xml"::xmlfilestr.XMLtype::"?>"::nil;
    
    let sizelist xmlfilestr.XMLmarks -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list xmlfilestr.XMLmarks i -> mark in
        set ncont = strcat ncont XMLgetMarks mark;
      
      set i = i + 1;
    );
    
    ncont;
  );
}


XMLwrite(xmlfilestr, path){
let XMLserialize xmlfilestr -> ncont in
  if ncont == nil then nil else
    _storepack ncont path;
  0;
}


XMLload(path){
let (_checkpack path) -> pfile in
  if pfile == nil then 
  (
    _fooS strcat "XMLPARSER ERROR : file not found > " path;
    nil;
  )
  else
  (
    let _getpack pfile -> fcont in
    let mkXMLfile [path nil nil 0] -> xmlfilestr in
    (
      let strfindi "<?xml" fcont 0 -> shp in
      let strfind "?>" fcont 0 -> ehp in
      if ehp == nil then nil else
      (
        set xmlfilestr.XMLtype = substr fcont (shp + 5) ((ehp - shp) - 5);
        set fcont = substr fcont (ehp + 2) ((((strlen fcont) - 1) - ehp) -1);
      );
      if !iXMLdebug then nil else
        _fooS strcat "XMLPARSER DEBUG : type > " xmlfilestr.XMLtype;
      
      set xmlfilestr.XMLmarks = (XMLparse xmlfilestr fcont);
      xmlfilestr;
    );
  );
}


XMLloadString(fcont){
let mkXMLfile [nil nil nil 0] -> xmlfilestr in
  (
    let strfindi "<?xml" fcont 0 -> shp in
    let strfind "?>" fcont 0 -> ehp in
    if ehp == nil then nil else
    (
      set xmlfilestr.XMLtype = substr fcont (shp + 5) ((ehp - shp) - 5);
      set fcont = substr fcont (ehp + 2) ((((strlen fcont) - 1) - ehp) -1);
    );
    if !iXMLdebug then nil else
      _fooS strcat "XMLPARSER DEBUG : type > " xmlfilestr.XMLtype;
    
    set xmlfilestr.XMLmarks = (XMLparse xmlfilestr fcont);
    xmlfilestr;
  );
}


XMLdiff(xmlfilestr1, xmlfilestr2){
let strmd5 XMLserialize xmlfilestr1 -> nsign1 in
  let strmd5 XMLserialize xmlfilestr2 -> nsign2 in
    strcmpi nsign1 nsign2;
}


XMLcopy(xmlfilestr){
XMLloadString XMLserialize xmlfilestr;
}


XMLcreate(path, type){
let mkXMLfile [path type nil 0] -> xmlfilestr in
  (
    xmlfilestr;
  );
}
  

XMLsetPath(xmlfilestr, path){
set xmlfilestr.XMLpath = path;
}


/*
main(file){
_showconsole;
  let XMLload file -> xmlfilestr in
  (
    //XMLdelMark xmlfilestr 
    XMLaddMark xmlfilestr "test" (XMLgetMarkById xmlfilestr 6) nil "huhu";
    XMLwrite xmlfilestr "tests/xml/new.xml";
  );
  0;
}
*/
// -- [/filterPKG] --

---