tools.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.
-----------------------------------------------------------------------------
*/

lcat(p, q){
if p==nil then
    q
  else
    (hd p)::lcat (tl p) q;
}


divideList(x,p,r1,r2,f){
if p==nil then [r1 r2]
  else let p->[a n] in
  let exec f with [a x] -> r in
  if r==0 then divideList x n r1 r2 f
  else if r<0 then divideList x n a::r1 r2 f
  else divideList x n r1 a::r2 f;
}


divideListString(x,p,r1,r2,f){
if p==nil then [r1 r2]
  else let p->[a n] in
  let exec f with [strcatn a strcatn x] -> r in
  if r==0 then divideListString x n r1 r2 f
  else if r<0 then divideListString x n a::r1 r2 f
  else divideListString x n r1 a::r2 f;
}


divideListPos(x,p,r1,r2,pos,f){
if p==nil then [r1 r2]
  else let p->[a n] in
  let exec f with [(nth_list a pos) (nth_list x pos)] -> r in
  if r==0 then divideListPos x n r1 r2 pos f
  else if r<0 then divideListPos x n a::r1 r2 pos f
  else divideListPos x n r1 a::r2 pos f;
}


divideList3(x,p,r1,r2,f){
if p==nil then [r1 r2]
  else let p->[a n] in
  let a->[aa _] in
  let x->[xx _] in
  let exec f with [aa xx] -> r in
  if r==0 then divideList3 x n r1 r2 f
  else if r<0 then divideList3 x n a::r1 r2 f
  else divideList3 x n r1 a::r2 f;
}


splitList(l, e, f){
if l == nil then [nil nil] else
    let l -> [head tail] in
    let splitList tail e f -> [left right] in
    if exec f with [head e] then
      [head::left right]
    else
      [left head::right];
}


isSmaller(s, t){
((strcmp s t) < 0);
}


isLarger(s, t){
((strcmp s t) > 0);
}


suppDoublon(s1,s2){
strcmpi s1 s2;
}


suppDoublon2(s1,s2){
s1!=s2;
}


quicksort(l,f){
if l==nil then nil
  else let l->[vl nl] in
  let divideList vl nl nil nil f->[va na] in
  lcat quicksort va f vl::quicksort na f;
}


quicksortByPos(l,pos,f){
if l==nil then nil
  else let l->[vl nl] in
  let divideListPos vl nl nil nil pos f->[va na] in
  lcat quicksortByPos va pos f vl::quicksortByPos na pos f;
}


quicksortList(l,f){
if l==nil then nil
  else let l->[vl nl] in
  let divideListString vl nl nil nil f->[va na] in
  lcat quicksortList va f vl::quicksortList na f;
}
  

quicksort3(l,f){
if l==nil then nil
  else let l->[vl nl] in
  let divideList3 vl nl nil nil f->[va na] in
  lcat quicksort3 va f vl::quicksort3 na f;
}


sortlist(l,f){
if l == nil then nil else
    let l -> [head tail] in
    let splitList tail head f -> [left right] in
    lcat (sortlist left f) head::(sortlist right f);
}


revertlist(list){
if list==nil then nil else
  let list -> [first next] in
    lcat revertlist next first::nil;
}


isStringInList(l, string){
(l!=nil)&&((!strcmp string hd l)||(isStringInList tl l string));
}


isStringInListi(l, string){
(l!=nil)&&((!strcmpi string hd l)||(isStringInListi tl l string));
}


isFirstWordInList(l, string){
(l!=nil)&&((!strcmp (hd hd (strextr string)) (hd l))||(isFirstWordInList tl l string));
}


isFirstWordInListi(l, string){
(l!=nil)&&((!strcmpi (hd hd (strextr string)) (hd l))||(isFirstWordInListi tl l string));
}


isFirstStringInList(l, string){
let hd hd l -> tstr in
  (l!=nil)&&((!strcmp string tstr)||(isFirstStringInList tl l string));
}


getPathFile(longfile, file){
if (longfile==nil) || (strlen longfile)==0 || (nth_char longfile ((strlen longfile)-1)) == '/ then
  (
    if (strfind "." file 0) != nil then
      [longfile file]
    else if file != nil then
      [strcatn longfile::file::"/"::nil nil]
    else
      [longfile nil];
  )
  else
    getPathFile
      substr longfile 0 (strlen longfile)-1
      strcat
        substr longfile ((strlen longfile)-1) 1
        file;
}


getlastPathDir(path){
while ((strfind "/" path 0) != nil) do
    set path = substr path ((strfind "/" path 0) + 1) 2048;
  path;
}


getFileExt(file){
let getPathFile file "" -> [_ file2] in
  let 0 -> pos in
  (
    while (strfind "." file2 pos + 1) != nil do
    (
      set pos = strfind "." file2 pos + 1;
    );
    substr file2 (pos + 1) 1024;
  );
}


getFilePathWithoutExt(file){
substr file 0 (strfind "." file 0);
}
  

// return the fileName without Path and Extension
getFileNameWithoutExt(file){
let getPathFile file "" -> [_ file2] in
  substr file2 0 (strfind "." file2 0);
}
  
  
/* manage relativ paths (relativ files should start with ./ */
getRelativePath(path, file){
if !strcmp substr file 0 2 "./" then
    strcatn path::"/"::(substr file 2 strlen file)::nil
  else file;
}


cutDotName(name){
[(substr name 0 (strfind "." name 0)) (substr name ((strfind "." name 0) + 1) 1024)];
}


makeDotName(id, name){
strcatn id::"."::name::nil;
}


getFilesFromDir(dir, mask){
let _listoffiles dir -> files in
  let nil -> lfiles in
  let sizelist files -> size in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list files i -> file in
      let getFileExt file -> ext in
      if !(isStringInList mask ext) then nil else
        set lfiles = lcat lfiles file::nil;
      
      set i = i + 1;
    );
    lfiles;
  );
}


getBooleanFromString(str){
if (!strcmpi strtrim str "enable") || (!strcmpi strtrim str "ON") || (!strcmpi strtrim str "true") || (!strcmpi strtrim str "yes") || ((atoi str) == 1) then 1 else 0;
}


isLastWordfromString(word, string){
!strcmpi word (substr string ((strlen string) - (strlen word)) (strlen word));
}


isFirstWordfromString(word, string){
!strcmpi word (substr string 0 (strlen word));
}


listLowercase(l){
let sizelist l -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list l i -> elem in
        set ndata = lcat ndata (strlowercase elem)::nil;
      
      set i = i + 1;
    );
    ndata;
  );
}


getFilesFromDirRecursive(dir){
if (isLastWordfromString ".svn" dir) then nil else
  let _listoffiles dir -> lfiles in
  let _listofsubdir dir -> lsubdirs in
  (
    let sizelist lsubdirs -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lsubdirs i -> elem in
        set lfiles = lcat lfiles (getFilesFromDirRecursive elem);
      set i = i + 1;
    );
    
    lfiles;
  );
}


getDirectoryWithoutLastSlash(dir){
if isLastWordfromString "/" dir then
    substr dir 0 ((strlen dir) - 1)
  else
    dir;
}


getDirectoryWithoutFirstSlash(dir){
if isFirstWordfromString "/" dir then
    substr dir 1 ((strlen dir) - 1)
  else
    dir;
}


apply_on_list(l,f,x){
if l==nil then 0
 else let l -> [a nxt] in
  (exec f with [a x];
   apply_on_list nxt f x);
}


rev_apply_on_list(l,f,x){
if l==nil then 0
 else let l -> [a nxt] in
  (rev_apply_on_list nxt f x;
   exec f with [a x];0);
}


search_in_list(l,f,x){
if l==nil then nil
 else let l -> [a nxt] in
  if exec f with [a x] then a
  else search_in_list nxt f x;
}


remove_from_list(l,p){
if l==nil then nil
 else let l -> [a nxt] in
  if a==p then nxt
  else a::remove_from_list nxt p;
}


remove_string_from_list(l, elt){
if l==nil
  then
    nil
  else
    let hd l -> elm in
    if !strcmpi elm elt then
      tl l
    else
      (hd l)::remove_string_from_list tl l elt;
}


remove_idx_from_list(l, idx){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if id == idx then
      tl l
    else
      (hd l)::remove_idx_from_list tl l idx;
}


remove_sid_from_list(l, sid){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if (!strcmp id sid) then
      tl l
    else
      (hd l)::remove_sid_from_list tl l sid;
}


remove_first_string_from_list(l, elt){
if l==nil
  then
    nil
  else
    let hd hd l -> elm in
    if !strcmpi elm elt then
      tl l
    else
      (hd l)::remove_first_string_from_list tl l elt;
}


remove_all_first_string_from_list(l, elt){
if l==nil
  then
    nil
  else
    let hd hd l -> elm in
    if !strcmpi elm elt then
      remove_all_first_string_from_list tl l elt
    else
      (hd l)::remove_all_first_string_from_list tl l elt;
}


remove_first_and_second_string_from_list(l, elt1, elt2){
if l==nil
  then
    nil
  else
    let hd hd l -> elm1 in
    let hd tl hd l -> elm2 in
    if (!strcmpi elm1 elt1) && (!strcmpi elm2 elt2) then
      tl l
    else
      (hd l)::remove_first_and_second_string_from_list tl l elt1 elt2;
}


remove_first_string_from_list_start_with(l, elt){
if l==nil
  then
    nil
  else
    let hd hd l -> elm in
    if !strcmpi (substr elm 0 (strlen elt)) elt then
      remove_first_string_from_list_start_with tl l elt
    else
      (hd l)::remove_first_string_from_list_start_with tl l elt;
}


pos_in_list(l,p,n){
if l==nil then nil
 else let l -> [a nxt] in
  if a==p then n
  else pos_in_list nxt p n+1;
}


create_tab(n,f,x){
let mktab n nil -> t in
 (let 0->i in while i<n do
  (set t.i=exec f with [i x];
   set i=i+1);
  t);
}


addFifo(x,f){
let x::nil -> l in
  if f==nil then [l l]
  else let f->[a b] in
  (mutate b<-[_ l]; [a l]);
}


getFifo(f){
if f==nil then [nil nil]
 else let f->[a b] in
  if a==b then [hd a nil]
  else [hd a [tl a b]];
}


sizeFifo(f){
if f==nil then 0
 else let f->[a _] in sizelist a;
}


concFifo(f,g){
if f==nil then g
 else if g==nil then f
 else let f->[a b] in let g->[c d] in
  (mutate b<-[_ c]; [a d]);
}
  
  
hexListToBignumList(l){
let sizelist l -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list l i -> elt in
      set ndata = lcat ndata (BigFromAsc elt)::nil;
      
      set i = i + 1;
    );
    ndata;
  );
}
  

strcatnSep(l, sep){
let sizelist l -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list l i -> elem in
      if i == 0 then
        set ndata = elem
      else
        set ndata = strcatn ndata::sep::elem::nil;
        
      set i = i + 1;
    );
    ndata;
  );
}


strreplace(s, from, to){
let 0 -> pos in
  let strlen from -> fsize in
  let strlen to -> tsize in
  if ((fsize <= 0) || (tsize <= 0)) then s else
  while ((set pos = strfind from s pos) != nil) do
    set s = strcatn (substr s 0 pos)::to::(substr s (pos + fsize) ((strlen s) - pos))::nil;
  
  s;
}


strreplacei(s, from, to){
let 0 -> pos in
  let strlen from -> fsize in
  let strlen to -> tsize in
  if ((fsize <= 0) || (tsize <= 0)) then s else
  while ((set pos = strfindi from s pos) != nil) do
    set s = strcatn (substr s 0 pos)::to::(substr s (pos + fsize) ((strlen s) - pos))::nil;
  
  s;
}


addSlashes(s){
let "" -> ret in
  let strextr s -> l in
  (
    let sizelist l -> size in
    let 0 -> i in
    while (i < size) do
    (
      let nth_list l i -> line in
        set ret = strcatn ret::"\\n"::(strcatnSep line "\ ")::nil;
      
      set i = i + 1;
    );
    ret;
  );
}


strTruncate(s, maxlen, rp){
if (strlen s) > maxlen then
    strcat substr s 0 (maxlen - (strlen rp)) rp
  else
    s;
}


strToList(s){
let nil -> ret in
  let strextr s -> l in
  (
    let sizelist l -> size in
    let 0 -> i in
    while (i < size) do
    (
      let nth_list l i -> line in
        set ret = lcat ret (strcatnSep line " ")::nil;
      
      set i = i + 1;
    );
    ret;
  );
}


listToString(l){
let nil -> ret in
  (
    let sizelist l -> size in
    let 0 -> i in
    while (i < size) do
    (
      let nth_list l i -> line in
      let strextr line -> lp in
        set ret = lcat ret (hd lp)::nil;
        
      set i = i + 1;
    );
    if ret == nil then nil else strbuild ret;
  );
}
  
  
/* ********************************************************************************************* /
  HTTP DOWNLOAD
/ ********************************************************************************************* */

cbDownloadFile(req, p, data, code){
let p -> [str url cbfun] in
  if (code == 0) then
  (
    mutate p <- [(strcat str data) _ _];
    0;
  )
  // download finished
  else if (code == 1) then
  (
    exec cbfun with [url (strcat str data)];
  )
  else
  (
    _fooS strcat ">>>>>>>>> Http download failed : " url;
    exec cbfun with [url nil];
    0;
  );
  0;
}


downloadFile(file, cbfun){
if (!strcmp (substr file 0 8) "https://") || (!strcmp (substr file 0 7) "http://") || (!strcmp (substr file 0 7) "file://") || (!strcmp (substr file 0 6) "ftp://") then
  (
    INETGetURL _channel file 0 @cbDownloadFile ["" file cbfun];
    0;
  )
  else
  (
    exec cbfun with [file nil];
  );
  0;
}
  

cbGetUrlContent(req, p, data, code){
let p -> [str url cbfun] in
  if (code == 0) then
  (
    mutate p <- [(strcat str data) _ _];
    0;
  )
  // download finished
  else if (code == 1) then
  (
    exec cbfun with [url (strcat str data)];
  )
  else
  (
    _fooS strcat ">>>>>>>>> Http download failed : " url;
    exec cbfun with [url nil];
    0;
  );
  0;
}


postUrl(url, params, cbfun){
if (!strcmp (substr url 0 8) "https://") || (!strcmp (substr url 0 7) "http://") || (!strcmp (substr url 0 7) "file://") || (!strcmp (substr url 0 6) "ftp://") then
  (
    INETGetURLex2 _channel "POST" url "content-type: application/x-www-form-urlencoded" params 0 @cbGetUrlContent ["" url cbfun];
    0;
  )
  else
  (
    exec cbfun with [url nil];
  );
  0;
}
 
// -- [/filterPKG] --

---