---------------------------------------------------------------------------
--GENERAL PURPOSE SPIFFY routines for FM music
---------------------------------------------------------------------------
-- Feel free to use any of these routines in your own Euphoria programs.
-- All of the routines in this file are general-purpose routines that
-- are used by FM.EX but dont do anything FM-specific
---------------------------------------------------------------------------

include misc.e
include file.e
include get.e

---------------------------------------------------------------------------

---constants---

constant true=1 
constant false=0

global constant stdin=0
global constant stdout=1
global constant failure=-1
                                      
--globals--
global integer PATH_SLASH

if platform()=LINUX then  --yes, believe it or not, HSPEAK can be compiled to run on Linux
  PATH_SLASH='/'
else
  PATH_SLASH='\\'  
end if

--redundant to the standard upper() and lower() functions I know, but I
--use them constantly, and almost never use the other wildcard functs.
--this avoids including wildcard.e

-- convert atom or sequence to lower case
global function hs_lower(object x)
    return x + (x >= 'A' and x <= 'Z') * ('a' - 'A')
end function

-- convert atom or sequence to upper case
global function hs_upper(object x)
    return x - (x >= 'a' and x <= 'z') * ('a' - 'A')
end function

---convert a delimited string into a sequence of strings---
global function explode(sequence s,sequence delim)
  sequence result
  integer pos
  result={}
  pos=match(delim,s)
  if pos then
    while pos do
      result=append(result,s[1..pos-1])
      s=s[pos+length(delim)..length(s)]
      pos=match(delim,s)
    end while
  end if
  result=append(result,s)
  return result
end function

--merge a sequence of strings into a single delimited string--
global function implode (sequence s,sequence glue)
  sequence output
  output={}
  if length(s) then
    output=s[1]
    for i=2 to length(s) do
      output &= glue & s[i]
    end for
  end if
  return output
end function

---exclude specified chars from a string sequence---
global function exclude(sequence s,sequence c)
  sequence result
  result={}
  for i=1 to length(s) do
    if not find(s[i],c) then
      result=append(result,s[i])
    end if
  end for
  return(result)
end function

--wraps value() and returns a default if it fails
global function string_to_object(sequence s,object default)
  object result
  result=value(s)
  if result[1]!=GET_SUCCESS then
    result[2]=default
  end if
  return result[2]
end function

---collapse reundant elements of a sequence---
global function redundx(sequence s,object c)
 sequence n
 n=""
 for i=1 to length(s) do
  if compare(s[i],c)=0 then
   if i<length(s) then
    if compare(s[i+1],c)!=0 then
     n=append(n,s[i]) 
    end if
   else
    n=append(n,s[i]) 
   end if
  else
   n=append(n,s[i]) 
  end if
 end for
 return n
end function

---collapse all redundant elements of a sequence---
global function redundall(sequence s)
 sequence n
 n=""
 for i=1 to length(s) do
  if i<length(s) then
   if compare(s[i+1],s[i])!=0 then
    n=append(n,s[i]) 
   end if
  else
   n=append(n,s[i]) 
  end if
 end for
 return n
end function

--returns a column of a sequence of sequences--
global function column(sequence s,integer column)
  for i=1 to length(s) do
    s[i]=s[i][column]
  end for
  return s
end function

--substitute all instances of one object in a sequence with another object--
global function substitute(sequence seq, object old, object new)
  for i=1 to length(seq) do
    if compare(seq[i],old)=0 then
      seq[i]=new
    end if
  end for
  return seq
end function

--substitute all instances of a slice--
global function substring_replace(sequence seq,sequence old, sequence new)
  integer at
  integer start
  at=match(old,seq)
  start=1
  while at>=start do
    seq=seq[1..at-1] & new & seq[at+length(old)..length(seq)]
    start=at+length(new)
    at=match(old,repeat(0,start-1) & seq[start..length(seq)])
  end while
  return(seq)
end function

--normalize a pathname to use forward slashes--
global function filenamix(sequence s)
  return substitute(s,'\\','/')
end function

--normalize a pathname to use back slashes--
global function filenamos(sequence s)
  return substitute(s,'/','\\')
end function

--normalise a pathname to use the platform specific path delimiter--
global function normalize_filename(sequence s)
  if platform()=LINUX then
    return filenamix(s)
  else
    return filenamos(s)
  end if
end function

--extract only portion of a string after the last of a delimiter--
global function get_suffix(sequence s,sequence delim)
  sequence broken
  broken=explode(s,delim)
  return broken[length(broken)]
end function

--extract all of a string except what follows the last of a delimiter--
global function without_suffix(sequence s,sequence delim)
  sequence broken
  broken=explode(s,delim)
  if length(broken)>1 then
    return implode(broken[1..length(broken)-1],delim)&delim
  else
    return ""  
  end if
end function

--exclude the path from a fully qualified filename--
global function file_only(sequence filename)
  return get_suffix(filenamix(filename),"/")
end function

--return only the path from a fully qualified filename--
global function path_only(sequence filename)
  return without_suffix(filenamix(filename),"/")
end function

--return only the extension of a filename--
global function extension_only(sequence filename)
  return get_suffix(filename,".")
end function

--exclude the extension from a filename--
global function without_extension(sequence filename)
  sequence result
  result=without_suffix(filename,".")
  if length(result) then
    return result
  else
    return filename&"."  
  end if
end function

--returns a filename with the extension changed--
global function alter_extension(sequence filename,sequence newext)
  return without_extension(filename) & newext
end function

--return the larger of two integers--
global function large(integer n1,integer n2)
  if n1>n2 then
    return n1
  else
    return n2
  end if
end function

--return the smaller of two integers--
global function small(integer n1,integer n2)
  if n1<n2 then
    return n1
  else
    return n2
  end if
end function

--delete the first element of a sequence--
global function decapitate(sequence s)
  if length(s) then
    return s[2..length(s)]
  else
    return s  
  end if
end function

--return the absolute value of a number... how can this not be in the standard lib?--
global function abs(atom n)
  if n<0 then
    n*=-1
  end if
  return n
end function

--verify that a file exists--
global function file_exists(sequence f)
  integer fh
  integer result
  fh=open(f,"rb")
  if fh=-1 then
    result=false
  else
    close(fh)
    result=true
  end if
  return(result)
end function

--insert an object into a sequence--
global function insert_element(sequence s,object ob,integer index)
  if index=1 then
    return(prepend(s,ob))
  elsif index=length(s)+1 then
    return(append(s,ob))
  else
    return(append(s[1..index-1],ob)&s[index..length(s)])  
  end if
end function

--insert a sequence into a sequence--
global function insert_sequence(sequence s,sequence new,integer index)
  if index=1 then
    return(new&s)
  elsif index=length(s)+1 then
    return(s&new)
  else
    return(s[1..index-1]&new&s[index..length(s)])  
  end if
end function

--delete an element of a sequence
global function delete_element(sequence s,integer index)
  return(s[1..index-1]&s[index+1..length(s)])    
end function

--delete a slice from a sequence--
global function delete_slice(sequence s,integer first,integer last)
  return(s[1..first-1]&s[last+1..length(s)])
end function

--trim whitespace (tabs and spaces) from beginning and end--
global function trim_whitespace(sequence s)
  while s[1]=' ' or s[1]='\t' do
    s=s[2..length(s)]
  end while
  while s[length(s)]=' ' or s[length(s)]='\t' do
    s=s[1..length(s)-1]
  end while
  return s
end function

--create a blank alpha-tree
global function alpha_tree_create()
  --make space for all printable chars
  sequence tree
  tree=repeat({{},{}},95)
  return(tree)
end function

--stores text into a alphabet tree
global function alpha_tree_insert(sequence tree,sequence string,object data)
  tree[string[1]-31][1]=append(tree[string[1]-31][1],string)
  tree[string[1]-31][2]=append(tree[string[1]-31][2],data)
  return(tree)
end function

global function alpha_tree_mass_insert(sequence tree,sequence mass)
  --{{string,data},{string,data}}
  for i=1 to length(mass) do
    tree[mass[i][1][1]-31][1]=append(tree[mass[i][1][1]-31][1],mass[i][1])
    tree[mass[i][1][1]-31][2]=append(tree[mass[i][1][1]-31][2],mass[i][2])
  end for
  return(tree)
end function

--change the data for an existing string
global function alpha_tree_set_data(sequence tree,sequence string,object data)
  integer at
  at=find(string,tree[string[1]-31][1])
  tree[at][2]=data
  return(tree)
end function

--returns true if a gives string is in an alpha-tree--
global function alpha_tree_seek(sequence tree,sequence string)
  if length(string) then
    return(find(string,tree[string[1]-31][1]))
  else
    return(false)  
  end if
end function

--returns the data associated with a string in a tree--
global function alpha_tree_data(sequence tree,sequence string,object default)
  integer at
  if length(string)=0 then
    return(default)
  end if
  at=find(string,tree[string[1]-31][1])
  if at then
    return(tree[string[1]-31][2][at])
  else
    return(default)
  end if
end function

global function string_is_an_integer(sequence s)
  object o
  o=value(s)
  if o[1]=GET_SUCCESS then
    --translated to object
    if integer(o[2]) then
      --object is an integer
      --if compare(s,sprintf("%d",{o[2]}))=0 then
        --strict checking is disabled because 7 = 007
        --is exact match
        return(true)
      --end if
    end if
  end if
  return(false)
end function

---------------------------------------------------------------------------

--returns a number as a four-byte sequence in absurd byte order {3,4,1,2}
function absurd_byte_order(integer n)
  integer b1,b2,b3,b4
  b1=and_bits(n,#FF)
  b2=and_bits(n,#FF00)/#100
  b3=and_bits(n,#FF0000)/#10000
  b4=and_bits(n,#FF000000)/#1000000
  return{b3,b4,b1,b2}
end function

---------------------------------------------------------------------------

--converts a sequence of four bytes in {4,3,2,1} order into a single int
global function quad_to_integer(sequence quad)

  if length(quad)!=4 then
    --not a real quad
    return 0
  end if
  
  for i=1 to 4 do
    if not integer(quad[i]) then
      --not an integer
      return 0
    end if
    if quad[i]<0 or quad[i]>255 then
      --not a char
      return 0
    end if
  end for

  return quad[1]*#1000000 + quad[2]*#10000 + quad[3]*#100  + quad[4]
end function

---------------------------------------------------------------------------

--converts a sequence of 2 bytes in {2,1} order into a single int
global function word_to_integer(sequence word)

  if length(word)!=2 then
    --not a real word
    return 0
  end if
  
  for i=1 to 2 do
    if not integer(word[i]) then
      --not an integer
      return 0
    end if
    if word[i]<0 or word[i]>255 then
      --not a word
      return 0
    end if
  end for

  return word[1]*#100 + word[2]
end function

---------------------------------------------------------------------------

global function write_lump(integer filehandle,sequence name,sequence data)
  if length(name)>12 then
    --fail if name is too long
    return(false)
  end if
  puts(filehandle,hs_upper(name)&0)
  puts(filehandle,absurd_byte_order(length(data)))
  puts(filehandle,data)
  return(true)
end function

---------------------------------------------------------------------------

--returns the first x characters, avoiding word break.
--this is used to do the word-wrapping of long-lines
global function before_wrap_point(sequence string)
  sequence line,word,result
  integer size
  size=80
  result=string
  line=explode(string,"\n")
  if length(line) then
    word=explode(line[1]," ")
    result=""
    if length(word) then
      while length(word) do
        if length(result & word[1]) <= size then
          result &= word[1]
          word=decapitate(word)
          if length(word) then
            result &= " "
          end if
        else
          if length(word[1])>size then
            result &= word[1][1..large(0,size-length(result))]
          end if
          exit  
        end if
      end while
    else
      result&=line[1]
    end if
  end if
  return result
end function

---------------------------------------------------------------------------

--returns the remainder of a string after word wrapping one line
--this is used to do the word-wrapping of long-lines
global function after_wrap_point(sequence string)
  sequence result
  integer size
  size=80
  result=string[large(length(before_wrap_point(string)),1)+1..length(string)]
  if length(result) then
    if result[1]='\n' then
      result=decapitate(result)
    end if  
  end if
  return result
end function

---------------------------------------------------------------------------

global function get_whole_file(sequence filename)
  integer fh
  sequence whole_file,chunk
  whole_file={}
  if file_exists(filename) then
    fh=open(filename,"rb")
    while true do
      chunk = get_bytes(fh,100)
      whole_file &= chunk
      if length(chunk) < 100 then
        exit
      end if
    end while
    close(fh)
    return(whole_file)
  else
    return({})  
  end if
end function

---------------------------------------------------------------------------