Anubis / Anubis


   *Project*                             The Anubis Project
   
   *Title*                             Some basic definitions.
    
   *Copyright*                     Copyright (c) Alain Prouté 2001-2007. 


   *Author*       Alain Prouté
   *Author*       Olivier Duvernois
   *Author*       David René

   
   
   ----------------------------------- Table of Content ----------------------------------
   
   *** (1) Boolean functions
   
   *** (2) Int32 functions
      *** (2.1) Absolute value
      *** (2.2) Maximum
      *** (2.3) Minimum
      *** (2.4) Sum
      *** (2.5) Greatest
      *** (2.6) An alternative division which reports */0 = 0. 
      *** (2.7) Euclidian division
      *** (2.8) Raising an integer to an integer power. 
      *** (2.9) (Bool) int32_less
   
   *** (3) String functions
      *** (3.1) String + Int32
      *** (3.2) String + Word8
      *** (3.3) Bool -> String
      *** (3.4) a variant of the primitive 'sub_string'. 
      *** (3.5) '<' as another name for 'string_less'. 
      *** (3.6) Test if is an empty string
   
   *** (4) Generic functions on lists
      *** (4.1) Find element(s)
         *** (4.1.1) as nth from a list
         *** (4.1.2) Get a List($A) from a List($B)
         *** (4.1.3) Getting an element of List($T)
         *** (4.1.4) Getting elements of List($T)
      *** (4.2) member
         *** (4.2.1) 'member' with a non standard notion of equality 
         *** (4.2.2) 'member' for characters in strings. 
         *** (4.2.3) Lenght
      *** (4.3) A syntactical variant for 'append'
      *** (4.4) Merging two lists
         *** (4.4.1) with standrad comparison
         *** (4.4.2) with a non standard comparison:
      *** (4.5) Quick sorting of lists.
      *** (4.6) Randomly shuffling a list. 
         *** (4.6.1) Basic Shuffling
         *** (4.6.2) Shuffling a non empty list. 
      *** (4.7) Concatenating the elements of a list of strings.
      *** (4.8) Mapping functions
         *** (4.8.1) 'map' for non empty lists. 
         *** (4.8.2) 'map' with a parameter:
         *** (4.8.3) 'map and append'
         *** (4.8.4) 'map and select'. 
         *** (4.8.5) 'map and iterate'.
         *** (4.8.6) 'map select and iterate'. 
      *** (4.9) Check that all elements of a list have a given property:
      *** (4.10) Replace element in a list by its new_value
      *** (4.12) Getting the last element in a list. 
      *** (4.13) Transforming a non empty list into a list. 
      *** (4.14) List without doubles
   
   *** (5) Function facilities.
      *** (5.1) A generic 'identity' function.
      *** (5.2) Writing 'x..f' instead of 'f(x)'.  
   
   *** (6) Printable trees. 
      *** (6.1) Definition
      *** (6.2) Length
      *** (6.3) Reverse
      *** (6.4) 'member' for printable trees:
      *** (6.5) Printing a printable tree to the standard output. 
      *** (6.6) Thousands separators
   
   *** (7) A variant of 'write_to_file' able to write a printable tree. 
   
   *** (8) Putting a virtual machine at bed. 
   
   *** (9) Reliably  sending data
   
   *** (10) Transmitting serializable data. 
   
   *** (11) Time
      *** (11.1) Time conversions. 
      *** (11.2) Calculations with UTime.
   
   *** (12) Files and directories
      *** (12.1) Get the size of a file knowing its name.
      *** (12.2)  A predefined 'default' directory mode. 
      *** (12.3) Making a chain of directories. 
      *** (12.4) Make a directory with default mode
      *** (12.5) Testing if a file exists. 
      *** (12.6) Searching directories and subdirectories recursively. 
   
   *** (13) Manipulating characters
      *** (13.1)  Putting a character to lower case. 
      *** (13.2) Putting a string to lower case. 
      *** (13.3) 'crlf'
   
   *** (14) Prompting and reading from standard input. 
      *** (14.1) Reading a line from the standard input. 
      *** (14.2) Printing a prompt and reading the answer. 
      *** (14.3) The same one for a password
   
   *** (15) IP address
   
   *** (16) Graphical tools
      *** (16.1) lighten
      *** (16.2) darken
      *** (16.3) System font names
   
   ---------------------------------------------------------------------------------------

   
   *** (1) Boolean functions
   
public define Bool
  $T x /= $T y
   =
  if x = y then false else true. 
   
public define Bool 
  not
    (
      Bool x
    ) =
  if x then false else true. 

public define Bool 
  ~ Bool x
    =
  if x then false else true. 

public define $T -> Bool
   not
     (
       $T -> Bool f
     ) =
   ($T t) |-> not(f(t)). 
   
public define Bool
  xor
    (
      Bool x,
      Bool y
    ) =
   if x = y then false else true. 
   

public define Bool
   Bool x  | Bool y = 
  if x then true else y. 

public define $T -> Bool
   $T -> Bool f | $T -> Bool g 
     =
   ($T x) |-> if f(x) then true else g(x). 
   
public define $T -> Bool
   $T -> Bool f & $T -> Bool g 
     =
   ($T x) |-> if f(x) then g(x) else false. 
   


   *** (2) Int32 functions

      *** (2.1) Absolute value
      
public define Int32
   abs
     (
      Int32  x
     ) =
   if x < 0 then (x * (0 - 1)) else x.
   

      *** (2.2) Maximum
   
public define Int32
  max
    (
      Int32 x, 
      Int32 y
    ) =
  if x < y then y else x. 

   
   max and min for lists of integers. 
   
define Int32
   max             // auxilliary function 
     (
       Int32 x, 
       List(Int32) l
     ) =
   if l is 
     {
       [ ] then x,
       [h . t] then 
         if x < h
         then max(h,t)
         else max(x,t)
     }.
   
public define Int32
   max
     (
       NonEmptyList(Int32) l
     ) =
   if l is [h . t] then max(h,t). 

   
   
      *** (2.3) Minimum
   
   
public define Int32
  min
    (
      Int32 x, 
      Int32 y
    ) =
  if x < y then x else y. 

   
define Int32
   min             // auxilliary function 
     (
       Int32 x, 
       List(Int32) l
     ) =
   if l is 
     {
       [ ] then x,
       [h . t] then 
         if x < h
         then max(x,t)
         else max(h,t)
     }.
   
public define Int32
   min
     (
       NonEmptyList(Int32) l
     ) =
   if l is [h . t] then min(h,t). 
   

   
      *** (2.4) Sum
   
public define Int32
   sum
     (
       List(Int32) l
     ) =
   if l is 
     {
       [ ] then 0, 
       [h . t] then 
         h + sum(t)
     }.

   
      *** (2.5) Greatest
     
public define Int32
   greatest
     (
       List(Int32) l,
       Int32       i
     ) =
   if l is 
     {
       []      then i,
       [h . t] then 
         if i > h then greatest(t,i)
                  else greatest(t,h)
     }.

   
      *** (2.6) An alternative division which reports */0 = 0. 
   
public define Int32 
  Int32 d / Int32 a =
    if (Maybe(Int32))(d/a) is 
      { 
        failure then 0, 
        success(q) then q 
      }. 


public define Int32
   Int32 x % Int32 y
     =
   x(mod y). 
   
   
      *** (2.7) Euclidian division
   
   
   An  Euclidian division (with  positive remainder  as dictated  by the  theory). Indeed,
   mathematically, we must have:
   
         a = q*b + r
         0 =< r < |b|
   
public define (Int32,        // quotient
               Int32)        // remainder
   euclid
     (
       Int32 a,       // divide 'a' by 'b'
       Int32 b 
     ) =
   if (Maybe(Int32))(a/b) is 
     {
       failure then (0,0),
       success(q) then with r = a-q*b, 
         if r >= 0
         then (q,r)
         else (q-1,b+r)      // a = (q-1)b + (b+r)
     }.
   

   
   
      *** (2.8) Raising an integer to an integer power. 
   
public define Int32
   Int32 x ^ Int32 y
     = 
   if y = 0 then 1 else            // x^0 = 1
   if y = 1 then x else            // x^1 = x
   if y < 0 then alert else        // works for positive exponents only
   with z = x^(y>>1),              // z = x^p where x = 2p or x = 2p+1
   if ((y&1) = 0)                  // if y even
   then z*z                        // x^(2p)   = (x^p)*(x^p)
   else z*z*x.                     // x^(2p+1) = (x^p)*(x^p)*x
   
public define Int32 
  force_to_Int32
  (
    String value
  )=
  if string_to_integer(value) is
  {
    failure     then  0,
    success(n)  then n
  }.
  
      *** (2.9) (Bool) int32_less

public define Bool
   int32_less
     (
       Int32 i1,
       Int32 i2
     ) =
   i1 < i2.
   
   
   
   *** (3) String functions

      *** (3.1) String + Int32

public define String
   String s + Int32 i =
      s + integer_to_string(i). 

public define String
   Int32 i + String s =
      integer_to_string(i) + s. 

      *** (3.2) String + Word8

public define String
   String s + Word8 i =
      s + integer_to_string(word8_to_int32(i)). 

public define String
   Word8 i + String s =
      integer_to_string(word8_to_int32(i)) + s. 

      


   

    
      *** (3.4) a variant of the primitive 'sub_string'. 
   
public define String
  substr
    (
      String s, 
      Int32 start, 
      Int32 length
    ) =
  if sub_string(s,start,length) is 
    {
      failure then "",
      success(t) then t
    }. 
   
   
   
      *** (3.5) '<' as another name for 'string_less'. 
   
public define Bool
   String x < String y
     =
   string_less(x,y). 

   
   
      *** (3.6) Test if is an empty string

    empty means no characters or only spaces
   
define Bool
   is_empty
     (
       List(Word8) l
     ) =
   if l is 
     {
       []      then true,
       [h . t] then if h = ' ' then is_empty(t) else false,
     }.
   
public define Bool
   is_empty
     (
       String  s
     ) =
   is_empty(explode(s)).   

   
   
   
   
   
   *** (4) Generic functions on lists
   

      *** (4.1) Find element(s)

         *** (4.1.1) as nth from a list
   
public define Maybe($T)
  nth
    (
      Int32 n,
      List($T) l
    ) =
  if l is 
    {
      [ ] then failure, 
      [h . t] then 
        if n < 0 then failure else
        if n = 0 then success(h) else
        nth(n-1,t)
    }.
   

public define List($T)
  nthcdr
    (
      Int32 n, 
      List($T) l
    ) =
  if n =< 0 then l else
  if l is 
    {
      [ ] then [ ], 
      [h . t] then nthcdr(n-1,t)
    }.
   

public define $T
   force_nth
     (
       Int32 n, 
       List($T) l
     ) =
   if l is 
     {
       [ ] then alert, 
       [h . t] then 
         if n = 0 
         then h
         else force_nth(n-1,t)
     }. 

   
         *** (4.1.2) Get a List($A) from a List($B)

public define List($A)
   find_elements
     (
       List($B)             l,
       $B -> Bool        test,
       $B -> List($A)    to_a
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then 
         if test(h)
           then append(to_a(h),find_elements(t,test,to_a))
           else find_elements(t,test,to_a)
     }.
   
public define List($A)
   find_elements
     (
       List($B)       l,
       $B -> Bool  test,
       $B -> $A    to_a
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then 
         if test(h)
           then [to_a(h) . find_elements(t,test,to_a)]
           else find_elements(t,test,to_a)
     }.
   
   
public define List($A)
   find_elements
     (
       List($B)       l,
       $B -> $A    to_a
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then [to_a(h) . find_elements(t,to_a)]
     }.
   
   
         *** (4.1.3) Getting an element from List($T)
   
public define Maybe($T)
   find_element
     (
       List($T)       l,
       $T -> Bool  test
     ) =
   if l is 
     {
       []       then failure,
       [h . t]  then if test(h) then success(h) else find_element(t,test)
     }.
   
   
         *** (4.1.4) Getting elements from List($T)
   
public define List($T)
   find_elements
     (
       List($T)       l,
       $T -> Bool  test
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then if test(h) then [h . find_elements(t,test)] else find_elements(t,test)
     }.
   
   
   
   
      *** (4.2) member

   
         *** (4.2.1) 'member' with a non standard notion of equality 

public define Bool
  member
    (
      List($T) l, 
      $T       x, 
      ($T,$T) -> Bool compare
    ) = 
  if l is 
    {
      [ ] then false, 
      [h . t] then 
        if compare(h,x)
        then true
        else member(t,x,compare)
    }.


 
         *** (4.2.2) 'member' for characters in strings. 
   
define Bool
  member
    (
      Word8 c, 
      String s,
      Int32 n   
    ) =
  if nth(n,s) is 
    {
      failure then false, 
      success(d) then 
        if d = c
        then true
        else member(c,s,n+1)
    }.
   
public define Bool
  member
    (
      Word8 c, 
      String s
    ) =
  member(c,s,0). 
   

   
   A syntactical variant  for member, using the sign ':'  (remind of 'membership' relation
   in set theory).  'a:b' means that 'a' belongs to the list 'b'.
   
public define Bool
   $T a : List($T) b
     =
   member(b,a). 
   
   
   
   
   

         *** (4.2.3) Length
   
define Int32 
  length
    (
      List($T) l,
      Int32 n
    ) = 
  if l is 
    {
      [ ] then n, 
      [h . t] then length(t,n+1)
    }. 
  
public define Int32 
  length
    (
      List($T) l
    ) =
  length(l,0).

   
   
   
   Compute the average of a  list of integers. The average of a1,...,an is:
   
                 a1 + ... + an
            m =  -------------
                       n
   
   We  don't  want to  compute  a1+...+an  because of  the  limited  capacity  of 32  bits
   integers. Hence we compute as follows:
   
            m = a1/n + (a2+...+an)/n
              = a1/n + ((n-1)/n)*b
              = a1/n + (1 - 1/n)*b
              = (a1 - b)/n + b
   
   where b is the average (a2+...+an)/(n-1). 
   
define Int32
   average
     (
       List(Int32)   l,
       Int32         n     // length of l
     ) =
   if n < 10 then sum(l)/n else 
   if l is 
     {
       [ ]     then 0, 
       [h . t] then // here n is not 0
         with b = average(t,n-1),
           ((h-b)/n) + b 
     }.
   
public define Int32
   average
     (
       List(Int32)   l
     ) =
   average(l,length(l)). 
   

   

   
      *** (4.3) A syntactical variant for 'append'
   
   Given two lists L1 and L2, we would  like to write 'L1 + L2' instead of 'append(L1,L2)'
   (defined in 'predefined.anubis').   This is particularly useful when  we want to append
   more than two lists.
   
public define List($T)
  List($T) l1 + List($T) l2 
    =
  append(l1,l2). 
   
   Remark than since  '+' associates to the right, 'L1 +  L2 + L3' is read as  'L1 + (L2 +
   L3)'. Hence, L2 is first appended to  L3. Since, appending requires a copy of the first
   list, this is more efficient than if '+'  was associating to the left. In this case, L1
   is copied one time, not two times.
   
   
   Difference of two lists. 
   
public define List($T)
   List($T) a - List($T) b
     =
   if a is 
     {
       [ ] then [ ], 
       [h . t] then 
         if member(b,h)
         then t - b 
         else [h . t - b]
     }.
   
   The same one but with a given test of equality:
   
define List($T)
   substract
     (
       List($T)             a, 
       List($T)             b, 
       ($T,$T) ->  Bool     compare
     ) =
   if a is 
     {
       [ ] then [ ], 
       [h . t] then 
         if member(b,h,compare)
         then substract(t,b,compare)
         else [h . substract(t,b,compare)]
     }.

   
   A more convenient interface for this substraction:
   
public define List($T)
   List($T) a - (($T,$T) -> Bool, List($T)) b
     =
   if b is (compare,c) then 
   substract(a,c,compare). 
   
   
   
   

      *** (4.4) Merging two lists
   
         *** (4.4.1) with standrad comparison

   This is quite the same thing as  appending two lists, except that elements which are in
   both lists are put only one time in the result. Order of elements is not respected.

public define List($T)
  merge
    (
      List($T) l1, 
      List($T) l2
    ) =
  if l1 is 
    {
      [ ] then l2,
      [h . t] then 
        if member(l2,h)
        then merge(t,l2)
        else merge(t,[h . l2])
    }. 

   
   
         *** (4.4.2) with a non standard comparison:

public define List($T)
  merge
    (
      List($T) l1, 
      List($T) l2,
      ($T,$T) -> Bool compare
    ) =
  if l1 is 
    {
      [ ] then l2,
      [h . t] then 
        if member(l2,h,compare)
        then merge(t,l2)
        else merge(t,[h . l2])
    }. 


   
      *** (4.5) Quick sorting of lists.

define (List($H),List($H))
  separ
    (
      $H pivot,
      List($H) l, 
      ($H,$H) -> Bool less
    ) =
  if l is
    {
      [ ] then 
        ([ ],[ ]), 

      [h . t] then 
        with p = separ(pivot,t,less), 
          if p is
            {
              (f,s) then
                if less(h,pivot) is
                  {
                    false then
                      (f,[h . s]),
                    true then
                      ([h . f],s)
                  }
            }
    }.      

public define List($I) 
  qsort_aux
    (
      List($I) l,
      ($I, $I) -> Bool less
    ) = 
  if l is
    {
      [ ] then
        [ ],

      [h . t] then 
        with p = separ(h,t,less), 
          if p is (f,s) then
            append(qsort_aux(f,less),[h . qsort_aux(s,less)])                   
    }.


define Bool
   already_sorted
     (
       List($I) l, 
      ($I, $I) -> Bool less
     ) =
   if l is 
     {
       [ ] then true, 
       [h . t] then 
         if already_sorted(t,less)
         then if t is 
           {
             [ ] then true, 
             [u . v] then less(h,u)
           }
         else false
     }.
   
   
public define List($I) 
  qsort
    (
      List($I) l,
      ($I, $I) -> Bool less
    ) = 
  if already_sorted(l,less)
  then l
  else qsort_aux(l,less). 
   

   
   
      *** (4.6) Randomly shuffling a list. 

         *** (4.6.1) Basic Shuffling
   
define List($T)
  insert_at_position
    (
      Int32 pos, 
      $T h, 
      List($T) t
    ) =
  if pos = 0
  then [h . t]
  else if t is 
     {
       [ ] then [h], 
       [a . b] then 
         [a . insert_at_position(pos-1,h,b)]
     }.
   
define List($T)
  random_insert
    (
      $T h,
      List($T) t
    ) =
  with n = length(t), 
       r = random(n+1), 
    insert_at_position(r,h,t). 
   
public define List($T)
  shuffle
    (
      List($T) l
    ) =
  if l is
    {
      [ ] then [ ],
      [h . t] then random_insert(h,shuffle(t))
    }.
    
   
         *** (4.6.2) Shuffling a non empty list. 
   
   
public define NonEmptyList($T)
  shuffle
    (
      NonEmptyList($T) l
    ) =
  if l is [h . t] then 
  if shuffle((List($T))[h . t]) is 
    {
      [ ] then alert, 
      [h2 . t2] then [h2 . t2]
    }. 
   


      *** (4.7) Concatenating the elements of a list of strings.
   
public define String
   concat
     (
       List(String) l
     ) =
   if l is 
     {
       [ ] then "",
       [h . t] then h+concat(t)
     }. 

   with a separator between 2 strings : 
   
public define String
   concat
     (
       List(String) l,
       String       separator
     ) =
   if l is 
     {
       [ ]     then "",
       [h . t] then h+if t is [] then "" else (separator+concat(t,separator))
     }. 
   
   
   
      *** (4.8) Mapping functions
   
   
public define One
   map_forget
     (
       $A -> $B f, 
       List($A) l
     ) =
   if l is
     {
       [ ] then unique, 
       [h . t] then 
         forget(f(h)); map_forget(f,t)
     }.
   
   
         *** (4.8.1) 'map' for non empty lists. 
   
public define NonEmptyList($U)
   map
     (
       $T -> $U          f, 
       NonEmptyList($T)  l
     ) =
   if l is [h . t] then [f(h) . map(f,t)]. 
   
   
   
         *** (4.8.2) 'map' with a parameter:

public define List($C)
  map
    (
      ($A,$B) -> $C   f, 
      $A              p,
      List($B)        l
    ) =
  if l is 
    {
      [ ] then [ ],
      [h . t] then 
        with x = f(p,h), 
        [x . map(f,p,t)]
    }. 

   
   
         *** (4.8.3) 'map and append'
   
public define List($T)
   map_append
     (
       $A -> List($T)  f,
       List($A)        l
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then append(f(h),map_append(f,t))
     }.

   
   
         *** (4.8.4) 'map and select'. 
   
public define List($B)
   map_select
     (
       $A -> Maybe($B)    f, 
       List($A)           l
     ) =
   if l is 
     {
       [ ] then [ ], 
       [h . t] then 
         if f(h) is 
           {
             failure      then map_select(f,t),
             success(x)   then [x . map_select(f,t)]
           }
     }.
   
   
   
         *** (4.8.5) 'map and iterate'.
   
public define List($B)
   map_iterate
     (
       ($T,$A) -> $B      f, 
       List($A)           l,
       $T                 init,
       $T -> $T           next
     ) =
   if l is
     {
       [ ] then [ ], 
       [h . t] then 
         with x = f(init,h), 
         [x . map_iterate(f,t,next(init),next)]
     }. 
   
   
   
   
         *** (4.8.6) 'map select and iterate'. 
   
   
public define List($B)
   map_select_iterate
     (
       ($T,$A) -> Maybe($B)      f, 
       List($A)                  l,
       $T                        init,
       $T -> $T                  next
     ) =
   if l is
     {
       [ ] then [ ], 
       [h . t] then 
         if f(init,h) is 
           {
             failure     then 
               map_select_iterate(f,t,init,next),
             success(x)  then 
               [x . map_select_iterate(f,t,next(init),next)]
           }
     }. 
   
   
   
   

      *** (4.9) Check that all elements of a list have a given property:
   
       mapand(test,l) is true if and only if test(x) is true for all elements x of l. 

public define Bool
   mapand
     (
       $T -> Bool   test, 
       List($T)     l
     ) =
   if l is 
     {
       [ ] then true, 
       [h . t] then 
         if test(h)
         then mapand(test,t)
         else false
     }.
     
   
public define Bool
   mapor
     (
       $T -> Bool    test, 
       List($T)      l
     ) =
   if l is 
     {
       [ ] then false, 
       [h . t] then 
         if test(h) 
         then true
         else mapor(test,t)
     }. 

   
      *** (4.10) Replace element in a list by its new_value

public define List($T)
   replace_element
     (
       List($T)             l,
       $T -> Bool        test,
       $T           new_value
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then 
          if test(h)
            then [new_value . t]
            else [h . replace_element(t,test,new_value)]
     }.
   
public define List($T)
   replace_element
     (
       List($T)             l,
       $T -> Bool        test,
       $T -> $T     new_value
     ) =
   if l is 
     {
       []       then [],
       [h . t]  then 
          if test(h)
            then [new_value(h) . t]
            else [h . replace_element(t,test,new_value)]
     }.
   
   
  
 
   
   
         *** (4.12) Getting the last element in a list. 
   
public define Maybe($T)
   last
     (
       List($T) l
     ) =
   if l is 
     {
       [ ] then failure, 
       [h . t] then if t is 
         {
           [ ] then success(h), 
           [_ . _] then last(t)
         }
     }.
   
define List($T)
  remove_last
  (
    List($T)  l,
    List($T)  so_far
  )=
  if l is
  {
    [] then [],
    [h. t] then if t is
      {
        []  then reverse(so_far),
        [_ . _] then remove_last(t, [h . so_far])
      }
  }
  .
  
public define List($T)
   remove_last
     (
       List($T) l
     ) =
   remove_last(l, []). 
   
   

      *** (4.13) Transforming a non empty list into a list. 
   
public define List($T)
   to_list
     (
       NonEmptyList($T) nel
     ) =
   if nel is [h . t] then [h . t]. 
   

   
      *** (4.14) List without doubles
   
public define List($T)
   no_doubles
     (
       List($T)          l,
       ($T,$T) -> Bool   is_equal
     ) =
   if l is 
     {
       []      then [],
       [h . t] then if member(t,h,is_equal)
                      then no_doubles(t,is_equal)
                      else [h . no_doubles(t,is_equal)]
     }.
   
   
   
   *** (5) Function facilities. 
   
      *** (5.1) A generic 'identity' function 
   
public define $T
   identity
     (
       $T x
     ) =
   x. 
   
   
      *** (5.2) Writing 'x.f' instead of 'f(x)'.

   The next definition enables to write 'x.f' instead of 'f(x)' for applying a function to
   its argument (works for functions of 1 argument).  In particular, if 'f' is an implicit
   destructor (which  has always 1 argument) of  some type, this makes  the application of
   this  destructor look  like  the C  syntax 'x.f'  for  extracting a  component from  an
   agglomeration (analogous to a field from a structure).
      
   The binary operator  '.' has been introduced 2006/11/09 in  version 1.7.10. Because the
   fact that paragraphs must end by a dot (necessarily followed by either a white space, a
   line feed, a carriage return or a tabulator), this binary operator needs its right hand
   operand  glued onto  it.   So 'x. f'  will  not  be  correct, because  the  dot may  be
   understood as an end of paragraph.
   
   
public define $U
   $T x .$T -> $U f
     =
   f(x). 
   
   
   
   
   
   *** (6) Printable trees. 

      *** (6.1) Definition
   
   Trees whose leaves are strings, integers, ...

public type Printable_tree:
  [ ],   
  str_pt   (String,Printable_tree),     
  ba_pt    (ByteArray,Printable_tree), 
  int8_pt  (Word8,Printable_tree), 
  int32_pt (Int32,Printable_tree),
  pt_pt    (Printable_tree,Printable_tree).  

   
   Convenience functions, so that printable trees may be manipulated like lists. 
   
public define Printable_tree [String         x . Printable_tree y] = str_pt(x,y).
public define Printable_tree [ByteArray      x . Printable_tree y] = ba_pt(x,y).
public define Printable_tree [Word8           x . Printable_tree y] = int8_pt(x,y).
public define Printable_tree [Int32          x . Printable_tree y] = int32_pt(x,y).
public define Printable_tree [Printable_tree x . Printable_tree y] = pt_pt(x,y).
   
      *** (6.2) Length

public define Int32
   length
     (
       Printable_tree tr
     ) =
   if tr is 
     {
       [ ] then 0, 
       str_pt(s,t)      then length(s) + length(t), 
       ba_pt(b,t)       then length(b) + length(t),
       int8_pt(n,t)     then length(integer_to_string(word8_to_int32(n)))+length(t),
       int32_pt(n,t)    then length(integer_to_string(n))+length(t),
       pt_pt(u,v)       then length(u)+length(v)
     }.
   

      *** (6.3) Reverse
   
public define Printable_tree
  reverse
    (
      Printable_tree tr
    ) =
  if tr is 
    {
      [ ]               then (Printable_tree) [ ], 
      str_pt(s,t)       then (Printable_tree) [t , s], 
      ba_pt(b,t)        then (Printable_tree) [t , b], 
      int8_pt(i,t)      then (Printable_tree) [t , i], 
      int32_pt(n,t)     then (Printable_tree) [t , n], 
      pt_pt(u,v)        then (Printable_tree) [v . u]
    }. 
   
   
      *** (6.4) 'member' for printable trees:
   
   
public define Bool
  member
    (
      Word8 c, 
      Printable_tree tr
    ) = 
  if tr is 
    {
      [ ]                 then false, 
      str_pt(s,t)         then if member(c,s) then true else member(c,t),
      ba_pt(b,t)          then member(c,t), 
      int8_pt(d,t)        then if c = d then true else member(c,t), 
      int32_pt(n,t)       then member(c,t), 
      pt_pt(u,v)          then if member(c,u) then true else member(c,v)
    }. 
   
   
   
public define Printable_tree
   flat
     (
       List(Printable_tree) l
     ) =
   if l is 
     {
       [ ] then [ ], 
       [h . t] then [h . flat(t)]
     }. 
   
   
public define List($T)
   flat
     (
       List(List($T)) l
     ) =
   if l is 
     {
       [ ] then [ ], 
       [h . t] then h + flat(t)
     }.
   

   Dividing  a list  into a  list  of lists  of the  same  length (except  maybe the  last
   one). For example,
   
     [1,2,3,4,5,6,7,8,9]/4       and        [1,2,3,4,5,6,7,8,9]/3
   
   will give respectively:
   
     [[1,2,3,4],                            [[1,2,3],
      [5,6,7,8],                             [4,5,6],
      [9]]                                   [7,8,9]]
   
public define List(List($T))
   List($T) list / Int32 d          // d is supposed to be at least 1
     =
   if d < 1 then alert else
   with div = ((List($T) l, Int32 a) |-div->  // auxiliary recursive function 
     if l is 
       {
         [ ] then [ ],
         [h . t] then 
           if a = 1
           then [[h] . div(t,d)]
           else if (List(List($T)))div(t,a-1) is 
             {
               [ ]     then [[h]],
               [u . v] then [[h . u] . v]
             }
       }),div(list,d). 
   
   
   
   
   
   
      *** (6.5) Printing a printable tree to the standard output. 

public define Bool 
  print
    (
      Printable_tree tr
    ) =
  if tr is
    {
      [ ] then true, 
      str_pt(s,u) then if print_string(s) is
        { false then false, true then print(u) },
      ba_pt(b,u)     then if print_string(to_string(b)) is 
        { false then false, true then print(u) }, 
      int8_pt(a,u) then if print_int32(word8_to_int32(a)) is
        { false then false, true then print(u) }, 
      int32_pt(n,u) then if print_int32(n) is
        { false then false, true then print(u) }, 
      pt_pt(u,v) then if print(u) is
        { false then false, true then print(v) }
    }.



public define Bool
  print
    (
      WStream file, 
      Word8 c
    ) =
  if file <- c is 
    {
      failure then false, 
      success(_) then true
    }. 

public define Bool
  print
    (
      WStream file, 
      List(Word8) l
    ) =
  if l is 
    {
      [ ] then true, 
      [h . t] then
        if file <- h is 
         { 
           failure then false, 
           success(_) then print(file,t)
         }
    }. 

public define Bool
  print
    (
      WStream file, 
      String s
    ) =
  with l = (List(Word8))explode(s), print(file,l). 
  


public define Bool
  print
    (
      WStream file, 
      Int32 n
    ) = 
  print(file,integer_to_string(n)). 

public define Bool 
  print
    (
      WStream file, 
      Printable_tree t
    ) =
  if t is
    {
      [ ] then true, 
      str_pt(s,u) then if (Bool)print(file,s) is
        { false then false, true then (Bool)print(file,u) },
      ba_pt(b,u)     then alert, 
      int8_pt(a,u) then if (Bool)print(file,word8_to_int32(a)) is
        { false then false, true then (Bool)print(file,u) }, 
      int32_pt(n,u) then if (Bool)print(file,n) is
        { false then false, true then (Bool)print(file,u) }, 
      pt_pt(u,v) then if (Bool)print(file,u) is
        { false then false, true then (Bool)print(file,v) }
    }.

   
      *** (6.6) Thousands separators
   
public define Printable_tree 
  three_digits(Int32 n) =
    if n < 10 then ["00" , n]
  else if n < 100 then ["0", n]
  else [n]. 

public define Printable_tree
  two_digits(Int32 n) =
    if n < 10 then ["0", n]
    else [n]. 



public define Printable_tree
  thousands_separators(Int32 n) =
    if n < 1000 then [n]
    else [thousands_separators(n/1000),
          " ",
          three_digits(n (mod 1000)) ]. 

    Example: print(thousands_separator(1760050530)) will produce:
             1 760 050 530 



public define Int32
  dot_position (List(Word8) l) = 
    if l is 
      {
        [ ] then 0,      /* dot not found => integer => may end with .0 */ 
        [h . t] then 
          if h = '.' | h = ',' then 0 else 1 + dot_position(t)
      }. 


public define List(Word8)
  insert_separators (
                     List(Word8) l,      /* characters in number */ 
                     Int32 n            /* number of digits for integral part mod 3 */ 
                    ) =
      if l is
        {
          [ ] then [ ],
          [h . t] then 
            if h = '.' | h = ',' then 
                 l // [h . insert_separators(t,0)]
            else
                 ( if n = 0 then [h . insert_separators(t,2)]
              else if n = 1 then if t is
                                   {
                                     [ ] then [h], 
                                     [u . v] then (if u = '.' | u = ',' then 
                                              [h . insert_separators(t,0)]
                                         else [h , ' ' . insert_separators(t,0)])
                                   }
              else               [h . insert_separators(t,1)] )
        }. 


public define Printable_tree
  thousands_separators(String s) =
  with 
       l = (List(Word8))explode(s),     /* explode the string */ 
       n = dot_position(l) (mod 3),    /* find the number of digits before dot or comma (mod 3) */ 
       [implode(insert_separators(l,n))]. 



   
   *** (7) A variant of 'write_to_file' able to write a printable tree. 
   
public define WriteFileResult
   write_to_file
     (
       String             file_path, 
       Printable_tree     content
     ) =
   if (Maybe(RWStream))file(file_path,new) is 
     {
       failure then cannot_open_file, 
       success(f) then 
         if print(weaken(f),content)
         then ok
         else write_error(0)
     }. 
       
   
   
   *** (8) Putting a virtual machine at bed. 
   
   The  next   function  forces  the  virtual   machine  to  sleep  during   a  number  of
   milliseconds. This  works because  the virtual machine  waits 'ms'  milliseconds before
   computing 'true' for  the first time. Since 'true' is  always 'satisfied', the function
   returns 'unique' immediatly after this first computation of 'true'. 
   
public define One
  sleep
    (
      Int32 ms       // number of milliseconds to sleep
    ) =
  checking every ms milliseconds, wait for true then unique. 
   

   
   
   *** (9) Reliably  sending data
   
   
   We need  a function  for reliably  sending data, because  'write_file' does  not always
   write all the bytes of the given byte array.
   
read tools/connections.anubis   
   
define Maybe(Int32)
   reliable_write_aux
     (
       Connection connection,
       ByteArray ba,                                        // partial byte array
       Int32 already_sent,                                  // number of bytes already sent
       Int32 retries
     ) =
   if retries = 0 then failure else
   if write(connection,ba) is 
     {
       failure then 
         sleep(100);
         reliable_write_aux(connection,ba,already_sent,retries-1),
   
       success(n) then 
         if length(ba) = n
         then success(already_sent+n)
         else reliable_write_aux(connection,
                                 extract(ba,n,length(ba)),
                                 already_sent+n,
                                 20)
     }.
   
     
public define Maybe(Int32)
   reliable_write
     (
       Connection connection, 
       ByteArray ba
     ) =
   reliable_write_aux(connection,ba,0,20). 
   

   
   Debug version: 
   
 public define Maybe(Int32)
   reliable_write
     (
       Connection connection, 
       ByteArray ba
     ) =
   print("** ["+virtual_machine_id+"] Trying to write "+length(ba)+" bytes.\n");
   with result = reliable_write_aux(connection,ba,0),
     if result is 
       {
         failure then print("** ["+virtual_machine_id+"] Not all bytes written.\n"),
         success(n) then print("** ["+virtual_machine_id+"] "+n+" bytes written.\n")
       };
     result. 

   
   
   
   
   
public define Maybe(Int32)
   reliable_write
     (
       Connection conn, 
       Printable_tree t
     ) =
   if t is 
    {
      [ ] then success(0), 
   
      str_pt(s,u) then 
         if reliable_write(conn,to_byte_array(s)) is 
           {
             failure then failure,
             success(n) then if reliable_write(conn,u) is 
               {
                 failure then failure, 
                 success(m) then success(n+m)
               }
           },   
   
      ba_pt(b,u) then 
         if reliable_write(conn,b) is 
           {
             failure then failure,
             success(n) then if reliable_write(conn,u) is 
               {
                 failure then failure, 
                 success(m) then success(n+m)
               }
           },   
   
      int8_pt(a,u) then 
         if reliable_write(conn,to_byte_array(integer_to_string(word8_to_int32(a)))) is 
           {
             failure then failure,
             success(n) then if reliable_write(conn,u) is 
               {
                 failure then failure, 
                 success(m) then success(n+m)
               }
           },   

      int32_pt(a,u) then 
         if reliable_write(conn,to_byte_array(integer_to_string(a))) is 
           {
             failure then failure,
             success(n) then if reliable_write(conn,u) is 
               {
                 failure then failure, 
                 success(m) then success(n+m)
               }
           },   
   
      pt_pt(u,v) then 
         if reliable_write(conn,u) is 
           {
             failure then failure,
             success(n) then if reliable_write(conn,v) is 
               {
                 failure then failure, 
                 success(m) then success(n+m)
               }
           }   
    }.
   


   
   * Reliable read and write for TCP connections and files. 
   
   
public define Maybe(One)
   reliable_write
     (
       WStream conn, 
       ByteArray ba,
       Int32 already_sent, 
       Int32 retries
     ) = 
   if retries = 0 then failure else
   if write(conn,ba) is 
     {
       failure then 
         sleep(100); 
         reliable_write(conn,ba,already_sent,retries-1),
   
       success(n) then with l = length(ba), 
         if l = n
         then success(unique)
         else reliable_write(conn,
                             extract(ba,n,l),
                             already_sent+n,
                             20)
     }.
   
   
public define Maybe(One)
   reliable_write
     (
       RWStream conn, 
       ByteArray ba,
     ) = reliable_write(weaken(conn),ba,0,20). 
   
   
define Maybe(ByteArray)
   reliable_read
     (
       RStream conn,
       Int32 n,
       Int32 timeout,
       ByteArray so_far
     ) =
   if now > timeout then failure else
   if read(conn,n,1) is 
     {
       error    then failure,
       timeout  then failure,
       ok(ba)   then 
        with l = length(ba),
         if l = n
         then success(so_far+ba)
         else reliable_read(conn,n-l,timeout,so_far+ba)
     }. 

public define Maybe(ByteArray)
   reliable_read
     (
       RStream conn,
       Int32 n,
       Int32 timeout
     ) =
   reliable_read(conn,n,now+timeout,constant_byte_array(0,0)). 

public define Maybe(ByteArray)
   reliable_read
     (
       RWStream conn,
       Int32 n,
       Int32 timeout
     ) =
   reliable_read(weaken(conn),n,now+timeout,constant_byte_array(0,0)). 

   
   
   
   
   
   *** (10) Transmitting serializable data. 
   
   The  problem when  reading  a byte  array produced  by  a serialization  from a  TCP/IP
   connection is that  we must know how many  bytes to read before we  can unserialize the
   datum.  Hence, such  byte arrays must be transmitted prefixed by  their size.  The size
   itself (an  Int32) is serialized  before transmission. The  byte array obtained  by the
   serialization of an Int32 has 4  bytes (actually the Int32 itself in little-endian byte
   order).
   
   The next  two functions,  for sending  and receiving a  serializable datum,  handle the
   prefixing of the size together with the serialization and unserialization of the datum.
   Of  course,  any  serializable datum  sent  with  'send_datum'  must be  received  with
   'receive_datum'.
   
   
public define Maybe(One)
   send_datum
     (
       RWStream connection,
       $Datum datum
     ) =
   with sdatum = serialize(datum),
          size = length(sdatum),
   if reliable_write(connection,serialize(size)) is 
     {
       failure then failure, 
       success(_) then reliable_write(connection,sdatum)
     }.
   
   
public define Maybe($Datum)
   receive_datum
     (
       RWStream connection, 
     ) =
   if reliable_read(connection,4,10) is 
     {
       failure then failure, 
       success(ba_size) then if (Maybe(Int32))unserialize(ba_size) is 
         {
           failure then failure, 
           success(size) then if reliable_read(connection,size,10) is
             {
               failure then failure, 
               success(ba_datum) then (Maybe($Datum))unserialize(ba_datum)
             }
         }
     }.
   
   


   *** (11) Time
   
      *** (11.1) Time conversions. 

public define Int32 year(Int32 t)     = year(convert_time(t)). 
public define Int32 month(Int32 t)    = month(convert_time(t)). 
public define Int32 day(Int32 t)      = day(convert_time(t)). 
public define Int32 hour(Int32 t)     = hour(convert_time(t)). 
public define Int32 minute(Int32 t)   = minute(convert_time(t)). 
public define Int32 second(Int32 t)   = second(convert_time(t)). 
public define Int32 week_day(Int32 t) = week_day(convert_time(t)). 
public define Int32 year_day(Int32 t) = year_day(convert_time(t)). 
public define Bool  daylight_saving_time(Int32 t) = daylight_saving_time(convert_time(t)). 

public define Int32 
  date_and_time
    (
      Int32 y, 
      Int32 mo, 
      Int32 d, 
      Int32 h, 
      Int32 mi, 
      Int32 s,
      Bool  dst
    ) =
  convert_time(date_and_time(y,mo,d,h,mi,s,0,0,dst)). 
  

      *** (11.2) Calculations with UTime.

   A datum  of type  'UTime' is a  pair 'utime(s,m)' of  two 'Int32's.  Such a pair  is in
   'normal form' if either:
   
       - s >= 0 and 0    =< m  < 10^6
       - s =< 0 and -10^6 < m =< 0
   
   Notice that 'utime(s,m)' represents always '(10^6)s + m' microseconds even if it is not
   in normal form, and regardless of the signs of 's' and 'm'.
   
   All our fonctions below assume that their arguments are in normal form, and (under this
   assumption) return results in normal form.
   
   
define UTime
   normalize
     (
       Int32 s, 
       Int32 m
     ) =
   if s >= 0
   then if m < 0 
        then normalize(s-1,m+1000000)
        else if m >= 1000000 
             then normalize(s+1,m-1000000)
             else utime(s,m)
   else if m < -1000000 
        then normalize(s-1,m+1000000)
        else if m > 0 
             then normalize(s+1,m-1000000) 
             else utime(s,m). 
   
public define UTime
   normalize
     (
       UTime u
     ) =
   if u is utime(s,m) then normalize(s,m). 
   
public define Bool
   UTime u1 < UTime u2
     =
   if normalize(u1) is utime(s1,m1) then
   if normalize(u2) is utime(s2,m2) then 
   if s1 < s2 then true else 
   if s1 = s2 then m1 < m2 else
   false. 
   
   
public define Bool
   UTime u1 =< UTime u2
     =
   if normalize(u1) is utime(s1,m1) then
   if normalize(u2) is utime(s2,m2) then 
   if s1 =< s2 then true else 
   if s1 = s2 then m1 =< m2 else
   false. 
   
   
   
public define UTime
   UTime u1 - UTime u2
     =
   if u1 is utime(s1,m1) then 
   if u2 is utime(s2,m2) then
   normalize(s1-s2,m1-m2). 
   
public define UTime
   UTime u1 + UTime u2
     =
   if u1 is utime(s1,m1) then 
   if u2 is utime(s2,m2) then
   normalize(s1+s2,m1+m2). 
   
   
   
   
   
   *** (12) Files and directories
   
   
      *** (12.1) Get the size of a file knowing its name.
   
public define Int32
  file_size
    (
      String filename
    ) =
  if (Maybe(RStream))file(filename,read) is 
    {
      failure then 0, 
      success(file) then file_size(file)
    }.
   
   
      *** (12.2)  A predefined 'default' directory mode. 
   
public define DirectoryMode
  default_directory_mode
    = directory(readable,writable,searchable,
                non_readable,non_writable,non_searchable,
                non_readable,non_writable,non_searchable). 

  

      *** (12.3) Making a chain of directories. 
   
   The next function accepts  a directory path and a list of  string as its arguments, and
   constructs  in the  given  directory the  sequence  of directories  represented by  the
   elements of the list. For example,
   
      make_directories("/home/georges", ["first","second","third"])  
   
   will create the 3 directories:
   
       /home/georges/first
       /home/georges/first/second
       /home/georges/first/second/third
   
   If any  of them already exist,  there is no problem.  The function does  not return any
   information, and you may want to test if the directories have been created.
   
public define One
   make_directories
     (
       String dir, 
       List(String) path
     ) =
   if path is 
     {
       [ ]      then unique, 
       [h . t]  then 
         with new = if length(dir) = 0 then
                      if host_system is windows then
                        h
                      else
                        "/"+h
                    else
                      dir+"/"+h,
         forget(make_directory(new,default_directory_mode));
         make_directories(new,t)
     }.

   

      *** (12.4) Make a directory with default mode
   
define One
   make_directory_error
     (
       String path
     ) =
   print("Cannot create directory '"+path+"'.\n"). 
   
   
   
   
public define String     // returns the path of the directory
   make_directory
     (
       String path
     ) =
   if make_directory(path,default_directory_mode) is 
     {
       permission_denied      then make_directory_error(path), 
       name_already_exists    then unique,
       too_many_links         then make_directory_error(path),
       not_enough_room        then make_directory_error(path), 
       read_only_file_system  then make_directory_error(path),
       ok                     then unique
     };
   path. 
   
   
   
   
   
      *** (12.5) Testing if a file exists. 
   
public define Bool
   file_exists
     (
       String path
     ) =
   if (Maybe(RStream))file(path,read) is 
     {
       failure    then false, 
       success(_) then true
     }.
   
   
   
      *** (12.6) Searching directories and subdirectories recursively. 
   
public define List(String)
   recursive_directory_list
     (
       String directory_name,
       String file_name_mask
     ).
   
define List(String)   
   get_more_files
     (
       String dir, 
       String mask, 
       List(FileDescription) files
     ) =
   //print("*** "+dir+" "+mask+" ***\n"); 
   if files is 
     {
       [ ] then [ ], 
       [h . t] then 
         if h is 
           {
             no_info(_)             then get_more_files(dir,mask,t), 
             file(_,_,_,_)          then get_more_files(dir,mask,t),
             link(_,_,_,_)          then get_more_files(dir,mask,t), 
             directory(name,_,_)    then if name = "."  then get_more_files(dir,mask,t) else
                                         if name = ".." then get_more_files(dir,mask,t) else
                                         (recursive_directory_list(dir+"/"+name,mask)+
                                            get_more_files(dir,mask,t))
           }
     }. 
   
   
public define List(String)
   recursive_directory_list
     (
       String directory_name,
       String file_name_mask
     ) =
   with this_dir_files = (List(String))
     map((String s) |-> directory_name+"/"+s,reverse(directory_list(directory_name,file_name_mask))), 
   
   //print("Mask: "+file_name_mask+"\n"); 
   
   this_dir_files
   +
   get_more_files(directory_name,file_name_mask,directory_full_list(directory_name,"","","*")). 
   
   
   

   *** (13) Manipulating characters
   
      *** (13.1)  Putting a character to lower case. 
   
public define Word8
  to_lower
    (
      Word8 c
    ) =
  with n = word8_to_int32(c), 
  if ('A' =< n & n =< 'Z')
  then truncate_to_word8(n - 'A' + 'a')
  else c. 
   
public define Word8
  to_upper
    (
      Word8 c
    ) =
  with n = word8_to_int32(c), 
  if ('a' =< n & n =< 'z')
  then truncate_to_word8(n - 'a' + 'A')
  else c. 
   
   
      *** (13.2) Putting a string to lower case. 
   
define String 
  to_lower   
    (
      String s,
      Int32 n, 
      List(Word8) so_far
    ) =
  if nth(n,s) is 
    {
      failure then implode(reverse(so_far)), 
      success(c) then
        to_lower(s,n+1,[to_lower(c) . so_far])
    }.
   

public define String
  to_lower
    (
      String s
    ) =
  to_lower(s,0,[]). 
   
   
   
   
      *** (13.3) 'crlf'
   
   'crlf'  is a  string which  is required  by  the HTTP  protocol to  mark the  end of  a
   line. Any HTTP request or HTTP answer has  two parts (the second one may be empty): the
   header and the body. The header is  made of several lines (at least one), and separated
   from the body by a blank line. In other words, the header is separated from the body by
   a ''double crlf''.
   
public define String 
  crlf = implode([(Word8)13,10]).     i.e ASCII characters:   13 10  (in this order)
      
public define String crlfcrlf = implode([(Word8)13,10,13,10]).   
   
   
   
   

   *** (14) Prompting and reading from standard input. 

      *** (14.1) Reading a line from the standard input. 
   
define String
  read_line_from_stdin
    (
      List(Word8) so_far
    ) =
  if *stdin is 
    {
      failure then implode(reverse(so_far)), 
      success(c) then 
        if c = '\n'
        then implode(reverse(so_far))
        else read_line_from_stdin([c . so_far])
    }. 
   
   
   
      *** (14.2) Printing a prompt and reading the answer. 
   
public define String
  prompt
    (
      String header
    ) =
  print(header); 
  read_line_from_stdin([]). 
   

   
      *** (14.3) The same one for a password:
   
public define String
   prompt_for_password
     (
       String header
     ) =
   print(header);
   get_password.        // see 'predefined.anubis'
   
   
   
   
   
   *** (15) IP address
   
   
   An IP address is a Int32 which may be displayed numerically by the following function:
      
public define String
  ip_addr_to_string
    (
      Int32 addr
    ) =
  integer_to_string(addr&255) + "." +
  integer_to_string((addr>>8)&255) + "." +
  integer_to_string((addr>>16)&255) + "." +
  integer_to_string((addr>>24)&255).

   
   
   The following is used  when the bytes are not in network byte order  (as it is the case
   in RFC 1035 DNS messages).
   
public define String
  reverse_ip_addr_to_string
    (
      Int32 addr
    ) =
  integer_to_string((addr>>24)&255) + "." +
  integer_to_string((addr>>16)&255) + "." +
  integer_to_string((addr>>8)&255) + "." +
  integer_to_string((addr)&255).

   
   We can also construct IP addresses with:
   
public define Int32
   ip_address
     (
       (Word8,Word8,Word8,Word8) addr
     ) =
   if addr is (b3,b2,b1,b0) then
   (word8_to_int32(b0) << 24) |
   (word8_to_int32(b1) << 16) |
   (word8_to_int32(b2) << 8)  |
   (word8_to_int32(b3)).
   
   
   
   
   
   We may also need to transform a string like "123.456.789.123" into an integer IP address. 
   
define Bool
   is_digit
     (
       Word8 c
     ) =
   with n = word8_to_int32(c), 
   if n < '0' then false else n =< '9'. 
   
     
define Maybe((Int32,Int32))    // returns the next position for reading and a label. 
   read_label
     (
       String s,
       Int32 i,
       Int32 so_far
     ) =
   if nth(i,s) is 
     {
       failure then success((i,so_far)),
       success(c) then 
         if c = '.'
         then success((i+1,so_far))
         else if is_digit(c)
              then read_label(s,i+1,10*so_far+word8_to_int32(c)-'0')
              else failure
     }.
   
public define Maybe(Int32)
   ip_address
     (
       String s
     ) =
   if read_label(s,0,0) is 
     {
       failure then failure, 
       success(p1) then if p1 is (i2,lab1) then 
         if read_label(s,i2,0) is 
           {
             failure then failure,
             success(p2) then if p2 is (i3,lab2) then 
               if read_label(s,i3,0) is 
                 {
                   failure then failure, 
                   success(p3) then if p3 is (i4,lab3) then 
                     if read_label(s,i4,0) is 
                       {
                         failure then failure, 
                         success(p4) then if p4 is (i4a,lab4) then 
                           if i4a = length(s)
                           then success((lab4<<24)|(lab3<<16)|(lab2<<8)|lab1)
                           else failure
                       }
                 }
           }
     }.
   

   
   
   *** (16) Graphical tools
   
   
      *** (16.1) lighten

define Word8
   lighten
     (
       Word8 c,
       Int32 d
     ) =
   with n = word8_to_int32(c),
   truncate_to_word8(max(0,n+d)). 

public define RGBA
   lighten
     (
       RGBA color,
       Int32 d
     ) =
   if color is rgba(r,g,b,a) then 
   rgba(lighten(r,d),lighten(g,d),lighten(b,d),a). 
      
public define RGB
   lighten
     (
       RGB color,
       Int32 d
     ) =
   if color is rgb(r,g,b) then 
   rgb(lighten(r,d),lighten(g,d),lighten(b,d)). 

   
   
      *** (16.2) darken
   
public define RGBA
   darken
     (
       RGBA color,
       Int32 d
     ) =
   lighten(color,-d). 
   
public define RGB
   darken
     (
       RGB color,
       Int32 d
     ) =
   lighten(color,-d). 

   
   
      *** (16.3) System font names
   
   
public define List(String)   
   get_system_font_names
     =
   map((String fn) |-> substr(fn,0,length(fn)-3),
       directory_list(anubis_directory+"/library/system_fonts","*.sf")). 
   

   
      *** (16.4) Reading a color as an hexadecimal or decimal number. 
      
public define RGB
   rgb
     (
       Int32 x
     ) =
   rgb(truncate_to_word8(x>>16),
       truncate_to_word8(x>>8),
       truncate_to_word8(x)). 
   
   Examples:   rgb(5665433)
               rgb(0x3355cc)
   

   The same one for RGBA
   
public define RGBA
   rgba
     (
       Int32 x
     ) =
   rgba(truncate_to_word8(x>>24), 
        truncate_to_word8(x>>16),
        truncate_to_word8(x>>8),
        truncate_to_word8(x)). 
   
   
  Print the given string argument and adding newline. This is a convenience function to avoid type
  + "\n" at each end of print call.
   
public define One
  println
  (
    String line
  )=
  print(line + "\n").