New version 1.14: new form of 'delegate' taking priorities into account (see anu…

…bis_dev/manuals/en/Anubis-doc-1-13.pdf)

New version 1.14: new form of 'delegate' taking priorities into account (see anu…
…bis_dev/manuals/en/Anubis-doc-1-13.pdf)
Alain Prouté
1 parent b9f7794f
Showing 22 changed files with 671 additions and 204 deletions Show diff stats
anubis_dev/compiler/src/compil.h
anubis_dev/compiler/src/compile.c
anubis_dev/compiler/src/description.text
anubis_dev/compiler/src/expr.cpp
anubis_dev/compiler/src/grammar.y
anubis_dev/compiler/src/interp.c
anubis_dev/compiler/src/msgtexts.c
anubis_dev/compiler/src/optimize.c
anubis_dev/compiler/src/typetools.c
anubis_dev/compiler/src/vminstr.c
anubis_dev/include/bytecode.h
anubis_dev/include/minver.h
anubis_dev/library/web/torture_server.anubis
anubis_dev/manuals/en/Anubis-doc-1-13.pdf
anubis_dev/manuals/en/Anubis-doc-1-13.tex
anubis_dev/vm/src/AnubisProcess.cpp
anubis_dev/vm/src/AnubisProcess.h
anubis_dev/vm/src/anbexec.cpp
anubis_dev/vm/src/vm.cpp
anubis_dev/vm/src/vm.h
@@ -417,7 +417,9 @@ extern Expr              linecol(void);
   item(wait_for)\
   item(give_up)\
   item(delegate)\
+  item(delegatep)\
   item(start)\
+  item(startp)\
   item(finish)\
   item(copy_stack_ptr)\
   item(copy_stack_mixed)\
@@ -983,71 +985,7 @@ extern int max_tpair_load;
 #define cdr7(x)                       (cdr(cdr6(x)))
  
 extern Expr nthcdr(Expr n, Expr l);     // get n-th cdr of l
-   
-#define term_switch(term,name)\
-   switch(car(term)) {\
-   case alt_number:       goto alt_number_##name;\
-   case protect:          goto protect_##name;\
-   case lock:             goto lock_##name;\
-   case alert:            goto alert_##name;\
-   case debug_avm:        goto debug_avm_##name;\
-   case terminal:         goto terminal_##name;\
-   case integer:          goto integer_##name;\
-   case fpnum:            goto fpnum_##name;\
-   case symbol:           goto symbol_##name;\
-   case of_type:          goto of_type_##name;\
-   case constructor:      goto constructor_##name;\
-   case lambda:           goto lambda_##name;\
-   case app:              goto app_##name;\
-   case cond:             goto cond_##name;\
-   case select_cond:      goto select_cond_##name;\
-   case with:             goto with_##name;\
-   case string:           goto string_##name;\
-   case anb_read:         goto anb_read_##name;\
-   case anb_write:        goto anb_write_##name;\
-   case wait_for:         goto wait_for_##name;\
-   case delegate:         goto delegate_##name;\
-   case set:              goto set_##name;\
-   case omega_true:       goto omega_true_##name;\
-   case omega_false:      goto omega_false_##name;\
-   case serialize:        goto serialize_##name;\
-   case unserialize:      goto unserialize_##name;\
-   case bit_width:        goto bit_width_##name;\
-   case indirect_type:    goto indirect_type_##name;\
-   case vcopy:            goto vcopy_##name;\
-   default: internal_error("Unknown term",term); }\
-   
-   
-#define interp_switch(head,name)\
-   switch(car(head)) {\
-   case alt_number:       goto alt_number_##name;\
-   case protect:          goto protect_##name;\
-   case lock:             goto lock_##name;\
-   case avm:              goto avm_##name;\
-   case debug_avm:        goto debug_avm_##name;\
-   case terminal:         goto terminal_##name;\
-   case operation:        goto operation_##name;\
-   case string:           goto string_##name;\
-   case anb_int32:            goto int32_##name;\
-   case small_datum:      goto small_datum_##name;\
-   case fpnum:            goto fpnum_##name;\
-   case local:            goto local_##name;\
-   case app:              goto app_##name;\
-   case cond:             goto cond_##name;\
-   case select_cond_interp:      goto select_cond_interp_##name;\
-   case with:             goto with_##name;\
-   case constructor:      goto constructor_##name;\
-   case anb_read:         goto anb_read_##name;\
-   case anb_write:        goto anb_write_##name;\
-   case wait_for:         goto wait_for_##name;\
-   case delegate:         goto delegate_##name;\
-   case serialize:        goto serialize_##name;\
-   case unserialize:      goto unserialize_##name;\
-   case bit_width:        goto bit_width_##name;\
-   case indirect_type:    goto indirect_type_##name;\
-   case vcopy:            goto vcopy_##name;\
-   default: internal_error("Unknown interpretation head",head); }\
-   
+      
  
 extern int length(Expr list);
  
@@ -1470,7 +1408,7 @@ extern Expr _symbols_in_interp(Expr);
                                debug(implems[id].offline_code); } while(0)
  
  
-extern Expr _debug(char *,Expr, char *filename, int line); 
+extern Expr _debug(const char *,Expr, char *filename, int line); 
 extern void _debug_nl(char *file, int line); 
 extern void _debug_msg(char *msg); 
  
@@ -1916,7 +1854,8 @@ extern const char *msgtext_unused_named_resurgent[];
 extern const char *msgtext_duplicate_type_name[]; 
 extern const char *msgtext_replaced_by[]; 
 extern const char *msgtext_undefined_macro[]; 
-
+extern const char *msgtext_priority_not_word8[];
+extern const char *msgtext_priority_ambiguous[]; 
  
  
 #ifdef __cplusplus
@@ -2985,6 +2985,66 @@ Expr compile_term(Expr head,
  
       /*---------------------------------------------------------------------------*/
  
+    case delegatep:
+      {
+        /* (delegate <lc> <head priority> <head (delegated)> . <head (body)>) */
+
+        /*
+          same as 'delegate' but with priority. The priority level must be computed
+          first (not push into the stack). Uses 'startp' instead of 'start'
+          should produce this: 
+        
+          <d virtual copies in stack of parent machine>
+          [priority]          priority in R
+          startp d a          start a machine with priority (in R), d items in the stack 
+                              and jump to 'a'
+   
+          [delegated]
+          <d virtual deletions in stack of child machine>
+          <deletion of R> (type is that of delegated)
+          
+          finish              will stop the child machine
+          
+        label a:
+          [body]
+   
+   
+          When  'finished'  is  executed,  there  are  still  2  words  in  the  stack.   Indeed,
+          'get_del_code_from_ctxt' does not  generate an instruction for deleting  the last 'ret'
+          of the context. Furthermore, an initial 0 has been pushed into the stack by 'start'. 
+
+        */
+        int d = length(ctxt); 
+        Expr a = new_addr_name(labs_none,0); 
+        Expr before_start = get_before_start_code(ctxt,env); 
+        Expr priority_code = compile_term(third(head),ctxt,env,nil); 
+        Expr delegated_code = compile_term(forth(head),ctxt,env,nil);
+        Expr virtual_deletions = get_del_code_from_ctxt(ctxt,env);
+        Expr body_code = compile_term(cdr4(head),ctxt,env,end_code); 
+   
+        code = mcons3(finish,
+                      cons(label,a),
+                      remove_check_stack(body_code)); 
+   
+        code = cons(get_del_instr(type_from_interpretation(third(head),env),env),code);   /* deleting R */ 
+          /* actually, deleting R is not useful because the type of the datum in R is 'One' */ 
+          assert(car(code) == no_instr); 
+        code = append(virtual_deletions,code); 
+        code = cons(cons(comment,new_string("deleting initial stack content")),code); 
+        code = append(delegated_code,code);
+
+        code = cons(mcons3(startp,new_integer(d),a),code);
+        code = append(priority_code,code); 
+        code = cons(cons(comment,new_string("computing priority level of new process")),code); 
+        code = append(before_start,code); 
+        code = cons(cons(check_stack,new_integer(stack_needs(body_code))),code); 
+      }
+      break; 
+
+
+
+      /*---------------------------------------------------------------------------*/
+
     case serialize:
     case tempserialize: 
       {
@@ -656,7 +656,8 @@
    (of_type <lc> <type> . <term>)          (explicit typing)
    (string <lc> . <string>)                (<string> is a Lisp-like string)
    (with <lc> <symbol> <value> . <term>)
-   (delegate <lc> <term> . <term>)
+   (delegate <lc> <term> . <term>)              (obsoleted by delegatep)
+   (delegatep <lc> <term> <term> . <term>)      (delegate (priority) delegated, body)
    (lambda <lc> <FArgs> . <term>)               (|->)
    (rec_lambda <lc> <name> <FArgs> . <term>)    (|-f->)
    (app <lc> <term> . <terms>)                  (applicative term)
@@ -743,6 +744,7 @@
    (with <lc> <symbol> <head> . <head>)
  
    (delegate <lc> <head> . <head>)
+   (delegatep <lc> <head> <head> . <head>)
    (serialize <lc> . <head>)
    (unserialize <lc> <type> . <head>)
  
@@ -1438,7 +1440,8 @@
  
             *** (2.3.5.8) Starting a new virtual machine. 
  
-      (start <depth> . <addr>)
+      (start <depth> . <addr>)                (obsoleted by startp)
+      (startp <priority> <depth> . <addr>)
  
    This  instruction is  generated by  the  keyword 'delegate'  and starts  a new  virtual
    machine. '<depth>' is the number of slots on  top of the stack of the old machine which
@@ -216,6 +216,9 @@ Expr pcons(Expr x, Expr y)
 /* saving an expression in the permanent zone */ 
 Expr save(Expr x)
 {
+
+   //debug(x); 
+
   if (is_tpair(x))
     {
       if (car(x) == anb_int32)
@@ -1155,7 +1158,7 @@ int sprint_tail(char *filep, Expr expr)
  
 int currently_debugging = 1; 
  
-Expr _debug(char *name, Expr expr, char * filename, int line)
+Expr _debug(const char *name, Expr expr, char * filename, int line)
 {
   if (currently_debugging)
     {
@@ -691,7 +691,8 @@ Term: yy__alert                                 { alert_obsolete($1);
 |     yy__with yy__tilde  yy__equals Term yy__comma WithTerm     { $$ = mcons5(with,$3,$2,$4,$6); }
 |     yy__checking_every Term yy__milliseconds yy__comma yy__wait_for Term yy__then Term  
                                                         { $$ = mcons5(wait_for,$1,$6,$2,$8); }
-|     yy__delegate Term yy__comma Term                      { $$ = mcons4(delegate,$1,$2,$4); }
+|     yy__delegate Term yy__comma Term                           { $$ = mcons4(delegate,$1,$2,$4); }
+|     yy__delegate yy__lpar Term yy__rpar Term yy__comma Term    { $$ = mcons5(delegatep,$1,$3,$5,$7); }
 |     yy__lpar FArgs1 yy__rpar yy__mapsto Term                   { $$ = mcons4(lambda,$4,$2,$5); }
 |     yy__lpar FArgs1 yy__rpar yy__rec_mapsto Term               { $$ = mcons5(rec_lambda,$3,$4,$2,$5); }
 |     yy__lbrace BEGINLBA yy__end_LBA       { $$ = mcons3(byte_array,$1,$3); }
@@ -122,6 +122,15 @@ Expr delegate_interpretations       (Expr lc,
                                      Expr env,
                                      Expr tvs); 
  
+Expr delegatep_interpretations      (Expr lc,
+                                     Expr ttype,
+                                     Expr priority, 
+                                     Expr delegated,
+                                     Expr body,
+                                     Expr ctxt,
+                                     Expr env,
+                                     Expr tvs); 
+   
 Expr serialize_interpretations      (Expr lc,
                                      int allow_serialize_Opaque, 
                                      Expr ttype,
@@ -2109,6 +2118,22 @@ term_interpretations(Expr ttype,      /* required type for that term (may contai
                                           env,
                                           tvs); 
       }
+       break; 
+       
+       
+    case delegatep:
+      {
+        /* (delegatep <lc> <term> <term> . <term>) */ 
+        term = cdr(term); 
+        result = delegatep_interpretations(car(term),    /* lc */ 
+                                           dummy,
+                                           second(term), /* priority */ 
+                                           third(term),  /* delegated */ 
+                                           cdr3(term),   /* body */
+                                           ctxt,
+                                           env,
+                                           tvs); 
+      }
       break; 
  
  
@@ -4591,12 +4616,12 @@ Expr wait_for_interpretations (Expr lc,
  
  
 Expr delegate_interpretations (Expr lc, 
-          Expr ttype,
-          Expr delegated,
-          Expr body,
-          Expr ctxt,
-          Expr env,
-          Expr tvs)
+                               Expr ttype,
+                               Expr delegated,
+                               Expr body,
+                               Expr ctxt,
+                               Expr env,
+                               Expr tvs)
 {
   /* 'delegate u, v' is correct if 'u' has a unique interpretation of type
      'One', and if 'v' may be interpreted. */ 
@@ -4613,7 +4638,7 @@ Expr delegate_interpretations (Expr lc,
   while (consp(aux))
     {
       if (type_from_interpretation(car(car(aux)),cdr(car(aux))) == pdstr_One)
- one_deleg_ints = cons(car(aux),one_deleg_ints); 
+        one_deleg_ints = cons(car(aux),one_deleg_ints); 
       aux = cdr(aux); 
     }
  
@@ -4656,11 +4681,133 @@ Expr delegate_interpretations (Expr lc,
     {
       /* each interpretation head is (delegate lc Ideleg . Ibody) */ 
       result = cons(cons(mcons4(delegate,
-    lc,
-    car(car(one_deleg_ints)),
-    car(car(body_ints))),
-    cdr(car(body_ints))),
-      result); 
+                                lc,
+                                car(car(one_deleg_ints)),
+                                car(car(body_ints))),
+                         cdr(car(body_ints))),
+                    result); 
+      body_ints = cdr(body_ints); 
+    }
+  return result; 
+}
+
+
+
+Expr delegatep_interpretations (Expr lc, 
+                                Expr ttype,
+                                Expr priority, 
+                                Expr delegated,
+                                Expr body,
+                                Expr ctxt,
+                                Expr env,
+                                Expr tvs)
+{
+  /* 'delegate u, v' is correct if 'u' has a unique interpretation of type
+     'One', and if 'v' may be interpreted. */ 
+
+  Expr priority_ints, word8_priority_ints, deleg_ints, one_deleg_ints, body_ints, aux, result; 
+
+  /* interpert priority (its type must be Word8) */ 
+  priority_ints = term_interpretations(dummy,priority,ctxt,env,tvs,0); 
+  if (priority_ints == nil) return nil; 
+
+  /* select only those interpretations which are of type 'Word8' */ 
+  aux = priority_ints; 
+  word8_priority_ints = nil; 
+  while (consp(aux))
+  {
+    if (type_from_interpretation(car(car(aux)),cdr(car(aux))) == pdstr_Word8)
+      word8_priority_ints = cons(car(aux),word8_priority_ints); 
+    aux = cdr(aux); 
+  }
+
+  /* we should have at least one interpretation of type 'Word8' */ 
+  if (word8_priority_ints == nil)
+    {
+      if (show_errors)
+        {
+          err_line_col(lc,"E123", 
+                       msgtext_priority_not_word8[0]); 
+          show_interpretations_types(errfile,priority_ints); 
+        }
+      return nil; 
+    }
+
+  /* we should not have several interpretations of type 'Word8' */ 
+  if (cdr(word8_priority_ints) != nil)
+    {
+      if (show_errors)
+        {
+          err_line_col(lc,"E124", 
+                       msgtext_priority_ambiguous[0]); 
+          show_simple_ambiguity(errfile,word8_priority_ints); 
+        }
+      return nil; 
+    }
+
+  /* update 'env' with the environment of the unique interpretation of 
+     the delegated term */ 
+  env = cdr(car(word8_priority_ints)); 
+
+  /* interpret delegated (its type must be 'One') */ 
+  deleg_ints = term_interpretations(dummy,delegated,ctxt,env,tvs,0); 
+  if (deleg_ints == nil) return nil; 
+
+  /* select only those interpretations which are of type 'One' */ 
+  aux = deleg_ints; 
+  one_deleg_ints = nil; 
+  while (consp(aux))
+    {
+      if (type_from_interpretation(car(car(aux)),cdr(car(aux))) == pdstr_One)
+        one_deleg_ints = cons(car(aux),one_deleg_ints); 
+      aux = cdr(aux); 
+    }
+
+  /* we should have at least one interpretation of type 'One' */ 
+  if (one_deleg_ints == nil)
+    {
+      if (show_errors)
+        {
+          err_line_col(lc,"E057", 
+                       msgtext_delegated_not_one[0]); 
+          show_interpretations_types(errfile,deleg_ints); 
+        }
+      return nil; 
+    }
+
+  /* we should not have several interpretations of type 'One' */ 
+  if (cdr(one_deleg_ints) != nil)
+    {
+      if (show_errors)
+        {
+          err_line_col(lc,"E058", 
+                       msgtext_delegated_ambiguous[0]); 
+          show_simple_ambiguity(errfile,one_deleg_ints); 
+        }
+      return nil; 
+    }
+
+  /* update 'env' with the environment of the unique interpretation of 
+     the delegated term */ 
+  env = cdr(car(one_deleg_ints)); 
+
+  /* now, we have to interpret the 'body' term (in the same context) */ 
+  body_ints = term_interpretations(dummy,body,ctxt,env,tvs,0); 
+  if (body_ints == nil) return nil; 
+
+  /* finally, we have one interpretation for each interpretation of the
+     body term */ 
+  result = nil; 
+  while (consp(body_ints))
+    {
+      /* each interpretation head is (delegatep lc Ipriority Ideleg . Ibody) */ 
+      result = cons(cons(mcons5(delegatep,
+                                lc,
+                                car(car(word8_priority_ints)), 
+                                car(car(one_deleg_ints)),
+                                car(car(body_ints))),
+                         cdr(car(body_ints))),
+                    result); 
       body_ints = cdr(body_ints); 
     }
   return result; 
@@ -4668,6 +4815,10 @@ Expr delegate_interpretations (Expr lc,
  
  
  
+
+
+
+
 #ifdef toto
 Expr set_interpretations            (Expr lc,  
          Expr ttype,
@@ -435,10 +435,21 @@ const char *msgtext_wait_milliseconds_ambiguous[] =
 { "   The milliseconds delay after 'wait for' is ambiguous,\n   for the following reason:\n" }; 
  
 const char *msgtext_delegated_not_one[] = 
-{ "   The term after 'delegate' is not of\n   type 'One'. The types found are:\n" }; 
+{ "   The delegated term after 'delegate' is not of type 'One'.\n" 
+  "   The types found are:\n" 
+}; 
+
+const char *msgtext_priority_not_word8[] = 
+{
+  "   The priority level after 'delegate' is not of type 'Word8'.\n"
+  "   The types found are:\n"   
+};
  
 const char *msgtext_delegated_ambiguous[] = 
-{ "   The term after 'delegate' is ambiguous,\n   for the following reason:\n" }; 
+{ "   The delegated term after 'delegate' is ambiguous,\n   for the following reason:\n" }; 
+
+const char *msgtext_priority_ambiguous[] =
+{ "   The priority level after 'delegate' is ambiguous,\n   for the following reason:\n" }; 
  
 const char *msgtext_select_cond_incompatible_types[] = 
 { "   In the conditional, the type of the case body\n"
@@ -1048,6 +1048,16 @@ Expr optimize_definition_code(Expr code)
         code = optimize_copy_del(code);
       } while (changed); 
  
+  /* drive back del_stack instructions to the end of code */
+#if 0
+  if (optimization_flags & opt_flag_drive_back) 
+    do 
+      { 
+        changed = 0; 
+        code = drive_back(code);
+      } while (changed);
+#endif   
+   
   /* groups of instructions optimization */ 
 #if 1
   if (optimization_flags & opt_flag_grp) 
@@ -301,6 +301,10 @@ Expr _type_from_interpretation(Expr head, Expr env)
       result = type_from_interpretation(cdr3(head),env); 
       break; 
  
+    case delegatep: /* (delegate <lc> <head> <head> . <head>) */ 
+      result = type_from_interpretation(cdr4(head),env); 
+      break; 
+
       /*
     case omega_true:
     case omega_false:
@@ -292,6 +292,7 @@ int instruction_size(Expr instr, int offset)
       case mvar_slots_del_mixed:
       case select_index_indirect:
       case start:
+      case startp: 
       case type_mixed:
       case indirect_type_mixed:
       case del_stack_struct_ptr:
@@ -1482,6 +1483,13 @@ void translate_instruction(U8 *code_addr,
         *ptr += sizeof(U32); 
         break; 
  
+      case startp: /* (start <depth> . <addr>) */ 
+        *((*ptr)++) = i_startp; 
+        *((*ptr)++) = integer_value(second(instr));
+        *(((U32 *)(*ptr))) = offsets[integer_value(cdr2(instr))];
+        *ptr += sizeof(U32); 
+        break; 
+
       case _switch:  /* (switch a1 ... ak) -->
                         i_switch k a1 ... ak */ 
         {
@@ -168,6 +168,7 @@ typedef enum
   item(read_locvar)\
   item(write_locvar)\
   item(start)\
+  item(startp)\
   item(finish)\
   item(copy_stack_ptr)\
   item(copy_stack_mixed)\
 #define maj_version (1)
-#define min_version (13)
-#define rel_version (5)
+#define min_version (14)
+#define rel_version (0)
 #define build_version (0)
  
  
@@ -6,7 +6,7 @@
  
  
  
-   
+read tools/time.anubis
 read web/http_get.anubis   
  
  
@@ -19,6 +19,7 @@ define One
      ) =
    print(to_decimal(n)+"/"+to_decimal(i)+" "); 
    forget(http_get(addr,"/",[],[]));
+   //sleep(5000); 
    ask_pages(addr,n,i+1). 
  
  
@@ -29,7 +30,7 @@ global define One
      ) =
    with addr = if args is { [] then "127.0.0.1" , [ h . _] then h}, 
    forget(
-   delegate ask_pages(addr,0,0), 
+   delegate (247) ask_pages(addr,0,0), 
    delegate ask_pages(addr,1,0), 
    delegate ask_pages(addr,2,0), 
    delegate ask_pages(addr,3,0), 
@@ -598,7 +598,7 @@
 {\sl Alain Prouté}\\
 \ \\
 Last revision of this text~: \today\\
-Refers to version~: 1.13
+Refers to version 1.14 and subsequent versions
 \end{center}
  
  
@@ -892,7 +892,25 @@ is        &amp;&amp;  with
 \end{liste}
  
  
-\section{The typing system}
+
+\subsection{Syntactic considerations}
+
+
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+\section{The system of types}
 The typing system is the very heart of the Anubis programming paradigm. The safety of the code
 you produce is mainly a consequence of the design of the typing system, just as the soundness of a 
 bridge depends on the design of its piers. 
@@ -964,6 +982,25 @@ see below.
 %
 %
 %
+\subsection{Primitive types}
+
+
+
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
 \subsection{Defining named types}
 We now enter into the details of the definition of a new data type (named type) as in the example above 
 (first tool). 
@@ -985,7 +1022,7 @@ We now enter into the details of the definition of a new data type (named type) 
 %
 %
 %
-\subsection{Using functional types}
+\subsection{Functional types}
  
  
 %
@@ -1189,6 +1226,132 @@ a micro-context. Such a pair is generally called a ``closure&#39;&#39; in computer scien
 \subsection{Schemas}\mylabel{sec:schemas}
  
  
+
+\section{Objects}
+
+
+\subsection{Types versus classes and data versus objects}
+Object oriented programming has introduced the notions of ``object'' and ``class'', which are often
+thought of as generalizations of the notions of ``datum'' and ``type''. I don't agree with this point 
+of view because data and objects have very different behaviors. In particular, I think that the 
+``all object'' paradigm, adopted by several computer languages, is not at all a good idea, because
+objects are much more difficult to manipulate than data. Doing so puts on data an unnecessary burden. 
+Of course, if you don't perceive the difference between an object and a datum, the above discussion
+is probably meaningless for you. In any case, I discuss this difference below. 
+
+First of all, let's take a real life example. Consider the following two ``things''~: (1) a number (for example, 
+the number $\pi=3,1415\dots$), and (2) a chair~:
+\begin{center}
+\includegraphics[width=80mm]{pi_chair.png}
+\end{center}
+It should be obvious that these two ``things'' don't have the same behavior. For example, you can burn
+the chair, but it is very unlikely that you are able to burn the number $\pi$. Maybe, you can burn
+a piece of paper with $\pi$ printed on it, but you cannot burn the number itself. Unlike the chair, 
+$\pi$ is undestroyable. This is a first difference, but there are many others. 
+
+For example, you can have two ``identical'' chairs, more precisely two ``copies'' of the same chair, but 
+what would it mean to have two copies of the number $\pi$~? I assure you that mathematicians never consider
+copies of the number $\pi$. They never say ``a number $\pi$'', but always ``the number $\pi$'', which is therefore
+unique, unlike the chair. 
+
+As another example, it is clear that the chair shown above was made at some time in the past. It has 
+a ``birth date''. Dou you thing that the number $\pi$ has a birth date~? For sure, there is a date (that 
+we are unable to determine) at which this number was discovered on the planet earth. But the number $\pi$
+ already existed before this date, and maybe was discovered earlier on another planet. 
+
+As a conclusion regarding this example, we will say that {\sl the chair is an object}, and that 
+{\sl the number $\pi$ is not an object}. 
+
+Now, let's take an example more interesting for programmers. Consider again a number (say a 32 bits number, 
+of type \code{Word32} in Anubis), and a network connection (of type \code{RWStream} in Anubis). 
+Like the chair, a connection has a birth date, since in order to have a connection we need to ``open''
+a connection. The time at which we open the connection is its birth date. You can also destroy (burn~!) the 
+connection just by ``closing'' it. 
+
+
+
+\subsection{Dynamic variables}
+Anubis has a special kind of objects called ``dynamic variables''. In programming, the word ``variable''
+generally represents some place in memory where a datum of a certain type can be stored. For example, 
+in the language C, you can write~:
+\begin{verbatim}
+int i; 
+\end{verbatim}
+which means that you want some place able to contain an integer (of type {\tt int} in this case). Notice
+that in the above example, this place is considered as ``empty'' since, I did not give it an ``initial value'', 
+but the important thing is that you can put a value (an ``int'') into it, and that you can also change this value at will
+during the execution of your program. 
+Notice that {\tt i} is called a ``variable'' just because its content may vary. 
+
+In the language C, and many other languages since the paradigm of C has spread almost everywhere in programming languages, 
+such a variable is either ``local'' or ``global'' depending on the fact that it is declared within the body
+of a function or not. 
+In Anubis, you don't have local variables of the above sort. This is also linked to the fact that Anubis has no
+notion of loop (at least explicitely). See the discussion on functions for more details on this question. 
+Anubis also does not have global variables in the above sens. There are global notions in Anubis, but none deserves the 
+name of ``variable''.  
+
+Before going further, remark that a variable in the above sens (i.e. a place whose content may change during execution)
+cannot be a datum, but is necessarily an object. Indeed, you can have two variables, for example declared in C like this~:
+\begin{verbatim}
+int i = 3; 
+int j = 3; 
+\end{verbatim}
+which are in some sens ``identical'', because they are of the same type and contain the same number. Nevertheless, you know that they 
+are not identical, for example because a confusion between them is most probably a bug. These two variables are like two chairs of the same model. 
+They are at the same time ``identical'' (same type, same content), and distinct because they are not at the same place in memory, 
+just like two ``identical'' chairs cannot be at the same place in your dinning room (according to Pauli's principle, since they are 
+made of fermions). 
+
+Probably, a variable like {\tt i} above could better be called a `container'', because its only 
+purpose is to ``contain'' something. However (again~!), what should better be called a container is not {\tt i}
+but {\tt \&i}, the ``address'' of {\tt i}. Indeed, in the language C, {\tt i} does not represent the place where
+the number is stored, but the very number stored in this place, i.e. only the content of the container. 
+Nevertheless, this is still {\tt i} which is called a ``variable'' and not {\tt \&i}, probably because what may vary
+is not the container itself but its content. 
+
+As a conclusion of the above discussion, we can say for sure that the ``container'' (aka. the ``variable'') is an object. 
+
+Now, comming back to Anubis, we have the notion of ``dynamic variable'', which designates a container (hence an object), 
+which is at the same time ``variable'' (its content may change during execution) and ``dynamic'' (it can be created/destroyed
+during execution). 
+
+The purpose of dynamic variables in Anubis is not to be used as storage places for making abstract computations. In Anubis
+(and in functionnal languages in general), abstract computations must better avoid the use of any object. Avoiding the use 
+of any object entails that the program is deterministic. This has the important consequence that it is more easy to understand, 
+and consequently less error prone. 
+
+The main uses of dynamic variables is (1) the creation of objects, (2) the communication between Anubis processes. 
+Below we first explain the syntax and semantics of dynamic variables, and in the subsequent sections we give examples
+of their uses. 
+
+\subsubsection{Syntax and semantics}
+A dynamic variable able to contain a datum of type \code{T} is itself of class \code{Var(T)}. In order to create
+a dynamic variable of class \code{Var(T)}, you must provide an initial content (of type \code{T}). The command~:
+\begin{center}
+\code{var(\sconcept{term})}
+\end{center} 
+(where \sconcept{term} is of type \code{T}) creates such a dynamic variable with initial content \sconcept{term}. 
+Thus, a dynamic variable is never empty, so that ``reading'' its content cannot produce an error. 
+
+If \code{v} is a dynamic variable of class \code{Var(T)}, \code{*v} (which is of type \code{T}) represents the 
+content of the variable, and if you want to change the value of the variable, use the command~:
+\begin{center}
+\code{v <- \sconcept{term}}
+\end{center} 
+where \sconcept{term} is the new content of \code{v}. The expression \code{v <- \sconcept{term}} is of type \code{One}, 
+so that it can be put in front of a semi-colon. 
+
+
+\subsubsection{Creating objects}
+
+\subsubsection{Communication between Anubis processes}
+
+\subsubsection{Functions and encapsulation}
+
+
+ 
+
 %
 %
 %
@@ -1293,7 +1456,24 @@ by something needing the body of their definition, a macro or an inline function
 it is defined (hence can also not be recursive). Unlike ordinary functions, declaring it is not enough for using~it. 
  
  
+\subsection{Serializing/unserializing data}
+
  
+
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
 \subsection{Primary and secondary modules (\code{load\_adm})}
 Each paragraph beginning by the keyword \code{global} produces a so-called ``module'', precisely, 
 an ``Anubis dynamic module'' (aka ``adm'') which is stored by the compiler into a file with 
@@ -1358,7 +1538,7 @@ it is possible to load a secondary module. It is of course possible to make this
 as shown by the web server defined in \code{library/web/dynamic\_http\_server.anubis}. This program 
 looks for secondary modules whose name matches the mask \code{*\_web\_site.adm}, and automatically
 loads them, or reloads them when they are recompiled, thus enabling to update the code of a web site 
-without stopping the web server. Even more, the new version and the previous version can work conccurently
+without stopping the web server. Even more, the new version and the previous version can work concurrently
 if a request answered by the previous version is still being serviced while the new version is already loaded
 and servicing another client.  
  
@@ -1521,48 +1701,54 @@ several so-called ``Anubis processes&#39;&#39; (``process&#39;&#39; for short). These processes 
 of the underlying operating system (Unix, Windows, \dots). 
  
 \subsubsection{Features and caveats}
+Anubis is multitasking because when I started to develop it around the year 2000, I had the idea to try to
+construct a small operating system (just as an exercice for fun). I abandonned this idea later (maybe not for ever), 
+but because of this, Anubis has a scheduler
+and is able to launch many processes within a single process of the host system. 
+
+This has advantages and disadvantages. The main avantage is that launching an Anubis process requires far 
+less memory than launching a process of the underlying system. This is mainly because all Anubis processes
+running in a single instance of \code{anbexec} share the same memory heap. Of course, each process has
+its own stack (which is small when the process is created but which can grown automatically), but
+all data which are not directly in the stack are in the common pool of memory. In particular, Anubis
+processes can share dynamic variables that they use as ``mailboxes'' for communicating. 
+
+This design allows for example the HTTP server defined in \code{library/web} to serve many clients
+simultaneously while still be running in a single thread of the host system. This is good for both speed
+and memory usage. 
+
+The main disadvantage is that a single instance of \code{anbexec} cannot use several physical processors. But it
+is still possible to launch several instances of \code{anbexec} collaborating through local connections and
+run by different physical processors. Of course, this needs a special conception of the whole project. It is 
+not impossible that in the future Anubis is enhanced for being able to use several physical processors 
+transparently. 
+
+
+
  
 \subsubsection{Syntax and semantics}
 In order to launch an Anubis process, use the keyword \code{delegate}. There are two distinct syntaxes
 for delegate~:
 \begin{dcode}
-      delegate <term>, <term>        // first form
-      delegate (<term>) <term>       // second form
+\hs      delegate \sconcept{term}, \sconcept{term}\\
+\hs      delegate (\sconcept{term}) \sconcept{term}, \sconcept{term}
 \end{dcode}
-with distinct semantics. 
-\begin{liste}
-\item First form~: Execution of \code{delegate a, b} works as follows~:
+The execution of \code{delegate a, b} works as follows~:
    \begin{liste} 
-   \item (1) a new Anubis process with priority 0 (background process) is created, 
-   \item (2) the term \code{a}, which must be of type \code{One}, is executed by this new process, 
+   \item (1) a new Anubis process with the same priority level as the current process is created, 
+   \item (2) the term \code{a} (which must be of type \code{One}) is executed by this new process, 
    \item (3) the current process executes \code{b}, 
    \item (4) the value returned by the whole expression \code{delegate a, b} is the value of~\code{b}. 
    \end{liste}
-   
-\item Second form~: Execution of \code{delegate (p) a} works as follows~:
-   \begin{liste}
-   \item (1) a new Anubis process is created with priority level \code{p} (of type \code{Word8}),
-   \item (2) the term \code{a}, which must be of type \code{One}, is executed by this new process, 
-   \item (3) the whole expression \code{delegate (p) a} returns immediately a datum of 
-             type \code{Process}, which identifies the new process. 
-   \end{liste}
-\end{liste}
-Remark that \code{delegate a, b} is equivalent to \code{forget(delegate (0) a); b}. 
-
-Of course, the second form is more powerful than the first one, but the first one is easier to use if
-you don't need to control the priority of processes. Normally, you don't mix boths forms of \code{delegate}
-in the same project. 
-
-\code{Process} is an opaque type. However, there are functions for manipulating processes. In particular,
-it is possible to change the priority level of a process during its execution. 
-
+The execution of \code{delegate (p) a, b} works in the same way except that the priority level of
+the new process is the minimum of the priority level of the current process and of the value of \code{p} 
+(which is of type \code{Word8}).  
  
  
 \subsubsection{Priority levels}
 The priority level of an Anubis process is a datum of type \code{Word8}, i.e. an integer whose value ranges
-from 0 to 255 (so, considered as positive or zero). Using the second form of \code{delegate}, you can set the priority of a process when it is created. 
-This priority can later be changed dynamically (i.e. during execution of the process), but be careful about that because
-changing the priority of a process during execution can dramatically affect other processes.
+from 0 to 255 (so, considered as positive or zero). Using the second form of \code{delegate}, you can set 
+the priority of a process when it is created. 
  
 The scheduler takes priority levels into account in the following manner. 
  
@@ -1575,85 +1761,41 @@ by the event puts itself back immediately into a sleeping state.
 This said, we are now concerned only by running processes. Each running process is run with
 a ``credit'' computed by the scheduler. This credit is the maximal number of virtual machine 
 instructions the process is allowed to execute before it must give up. The credit cannot be more
-than a given fixed value (which defaults to 500, but which can be changed using the option \code{-\sh-credit} with \code{anbexec}). 
+than a given fixed value (which defaults to 500, but which can be changed using the option \code{-\sh-credit} when
+launching \code{anbexec}). 
  
 The credit for running a process is computed as follows (at each passage into the chain of processes)~:
 \begin{liste}
 \item (1) the scheduler computes the maximum $M$ of the priority levels of all running processes, 
-\item (2) if the priority level of a process is less than or equal to $M-10$, it is not run, 
-\item (3) if the priority level $L$ of a process is between $M-9$ (included) and $M$ (included), it is run with a
-credit of $D(1 - \frac{M-L}{10})$, where $D$ is the default (maximal) credit. 
+\item (2) if the priority level of a process is less than or equal to $M-16$, it is not run, 
+\item (3) if the priority level $L$ of a process is between $M-15$ (included) and $M$ (included), it is run with a
+credit of $D(1 - \frac{M-L}{16})$, where $D$ is the default (maximal) credit. 
 \end{liste}
  
 Examples~:
 \begin{liste}
-\item We have two processes $A$ and $B$. 
+\item We have two processes $A$ and $B$, then~: 
    \begin{liste}
-   \item If $A$ has priority 50, and $B$ has priority $40$, $B$ must wait that $A$ is sleeping
-         for running.
-   \item If $A$ has priority 50 and $B$ has priority $45$, $B$ runs conccurently with $A$, but with half the credit of $A$ (i.e.
-         $A$ runs twice faster than $B$). 
-   \item If $A$ has priority 50 and $B$ has priority $49$, $B$ runs ten percent slower than $A$. 
+   \item If $A$ has priority $50$, and $B$ has priority $34$ or less, $B$ must wait that $A$ is sleeping
+         for being allowed to run.
+   \item If $A$ has priority $50$ and $B$ has priority $42$, $B$ runs concurrently with $A$, but with half the credit of $A$ (i.e.
+         $A$ runs twice ``faster'' than $B$). 
+   \item If $A$ has priority $50$ and $B$ has priority $49$, $B$ runs $6,25$ percent slower than $A$. 
    \end{liste}
-\item We have several processes $A_1,\dots,A_k$ with priority level 100, and several processes $B_1,\dots,B_n$ with priority
-      level 20. No $B$ process is running if at least one $A$ process is running. $B$ processes share the computation power
-      if no $A$ process is running.  
+\item We have several processes $A_1,\dots,A_k$ with priority level $100$, and several processes $B_1,\dots,B_n$ with priority
+      level $50$. No $B$ process is running if at least one $A$ process is running. $B$ processes share the computation power
+      when no $A$ process is running.  
 \item We can imagine a web site with absolutely prioritary processes (for administration), client processes (servicing web pages), 
-      and background task processes. The priorities could be set like this~: 20 for administration, 10 for clients, and 0 for the 
-      background. You can also imagine to put some administration task at the level 25.  
+      and background task processes. The priorities could be set like this~: 50 for administration, 30 for clients, and 0 for the 
+      background.   
 \end{liste}
+When anbexec starts, it runs a single process (the father of all processes). It has priority level~$255$.
  
-When anbexec starts, it runs a single process (the father of all processes). It has priority 255, and you can change this priority
-at the beginning of your program if needed. 
  
- 
-% 
-% 
-% 
-% 
-% 
-% 
-% 
-% 
-% 
-% 
-% 
-\subsubsection{Changing the priority level of a process}
-In order to change the priority level of a process, you need to be allowed to do so. The rules are~:
-\begin{liste}
-\item (1) A process can never have a priority level greater than its original priority level (the level it has when 
-          it was launched).
-\item (2) A process cannot launch a process with a priority level higher than its own priority level.            
-\item (3) A process can change its own priority level.
-\item (4) A process having access to a datum of type \code{Process} can change the priority level of the process
-          represented by this datum. 
-\end{liste}
-Remark that the only possibility to obtain a datum of type \code{Process} is to launch a process with \code{delegate}, 
-or to get it through the following tool (defined in \code{predefined.anubis})~:
-{\color{darkblue}
-\begin{verbatim}
-public define Process       my_process. 
-\end{verbatim}
-}
-If a process executes \code{my\_process}, it gets its own process identifier. 
  
-Getting and setting the priority level of a process is achieved by~:
-{\color{darkblue}
-\begin{verbatim}
-public define Word8         priority       (Process p). 
-public define One           set_priority   (Process p, Word8 level). 
-\end{verbatim}
-}
+\section{Anubis internals}
  
-For example, if a process wants at some time to run in the background, it can execute~:
-\begin{center}
-\code{set\_priority(my\_process,0)}
-\end{center}
-If later it needs to come back to its original priority level, it can execute~:
-\begin{center}
-\code{set\_priority(my\_process,255)}
-\end{center}
-The function \code{set\_priority} will put its priority level at its original value (which may be different from~255). 
+\subsection{The garbage-collector}
  
  
  
@@ -71,9 +71,13 @@ AnubisProcess::~AnubisProcess(void)
 }
  
 //int AnubisProcess::Create(int starting_point, U8 *byte_code, U32 code_size, AnubisAllocator *allocator)
-int AnubisProcess::Create(U8 * starting_IP, AnubisAllocator *allocator)
+int AnubisProcess::Create(U8 * starting_IP, U8 priority, AnubisAllocator *allocator)
 {
      /* retuns -1 if no machine available, the machine id otherwise. */ 
+     
+  m_priority = priority; 
+  
+  //printf("created process with priority %d\n",m_priority); fflush(stdout); 
  
   /* a machine has been found */ 
   /* give a stack to the machine */ 
@@ -328,14 +332,14 @@ AnubisProcessList::AnubisProcessList() :
 }
  
 //AnubisProcess * AnubisProcessList::CreateAnubisProcess(U32 starting_point, U8 *byte_code, U32 code_size, CM::AnubisAllocator * allocator)
-AnubisProcess * AnubisProcessList::CreateAnubisProcess(U8 * starting_IP, CM::AnubisAllocator * allocator)
+AnubisProcess * AnubisProcessList::CreateAnubisProcess(U8 * starting_IP, U8 priority, CM::AnubisAllocator * allocator)
 {
   AnubisProcess * processItem = new AnubisProcess();
   int pResult;    //result status of the create
  
   if (processItem)
   {
-    pResult = processItem->Create(starting_IP, allocator);
+    pResult = processItem->Create(starting_IP, priority, allocator);
     if (pResult >= 0)
     {
       AddItem(processItem);
@@ -60,7 +60,7 @@ class AnubisProcess
      * @param allocator
      * @return Return the process id of new created process, otherwise -1 for error
      */
-    int Create(U8 * starting_IP, AnubisAllocator *allocator);
+    int Create(U8 * starting_IP, U8 priority, AnubisAllocator *allocator);
  
     /** 
      * Set the pid of the process. usually is the process list who decide the pid of the 
@@ -121,7 +121,7 @@ class AnubisProcess
   protected:
   private:
     U32 m_pid;                           /* process unique id */
-    anbStatus m_status;                  /* current status of virtual machine */ 
+    anbStatus m_status;                  /* current status of this process */ 
     U32 m_work_sort;                     /* what it is currently doing */ 
     int m_steps;                         /* must be signed (((m_steps--) <= 0) in 'vm.cpp') */ 
     U32 m_R;                             /* main register of the machine */ 
@@ -130,9 +130,9 @@ class AnubisProcess
     //U32 m_starting_point;                /* keep trace of starting point for debugging purpose.*/
     U8* m_IP;                            /* instruction pointer */ 
     U8* m_previous_IP;                   /* previous value of instruction pointer */ 
-    U32 * m_SP_begin;                    /* address of machine's stack */ 
+    U32 * m_SP_begin;                    /* address of process stack */ 
     U32 * m_SP;                          /* stack pointer */ 
-    U32 * m_SP_end;                      /* end of machine's stack */ 
+    U32 * m_SP_end;                      /* end of process stack */ 
     /* the two fields below droped since version 1.13. They are incompatible with the loading
        of several modules, because the same process may execute code from different modules. 
        (the same is true of 'm_starting_point' above) */
@@ -154,7 +154,7 @@ class AnubisProcess
     //  U32 m_locked_files_stack_size;       /* current size of locked files stack */ 
     //  U32 m_locked_files_SP;               /* locked files stack pointer */ 
     //  U32 * m_locked_files;                /* stack of locked files (vm strings) */
-    U8    m_priority;                    //priority of the process
+    U8    m_priority;                    // current priority of the process
 #ifdef instruction_count
     U32 m_i_count[256];                  /* one counter for each instruction */
 #endif   
@@ -290,7 +290,7 @@ class AnubisProcessList : public List
     static AnubisProcessList* GetInstance();
     AnubisProcess * GetProcessAt(U32);
     AnubisProcess * GetProcessByID(U32);
-    AnubisProcess * CreateAnubisProcess(U8 * starting_IP, AnubisAllocator* allocator);
+    AnubisProcess * CreateAnubisProcess(U8 * starting_IP, U8 priority, AnubisAllocator* allocator);
     void DeleteProcess(U32 pid);
     AnubisProcess * GetRunningProcess() const { return _runningProcess; }
     void SetRunningProcess(AnubisProcess * current) { _runningProcess = current; }
@@ -713,8 +713,62 @@ static void calc_load(U32 ticks, U32 active_tasks /* fixed-point */, bigtime_t *
   }
 }
  
+/* Computing the maximum of the priority levels of all running (non sleeping) machines */
+static U8 max_priority_of_runnings(void)
+{
+  U32 i; 
+  U8 result = 0; 
+  U8 p; 
+  AnubisProcess * processItem;
+  U32 nbProcess = TheAnubisProcessList->GetCount();
+  for (i = nbProcess - 1; i != ~(U32)0; i--) // i-- with i unsigned and i = 0 is 111111111...1111 = ~0
+  {
+    processItem = TheAnubisProcessList->GetProcessAt(i);
+    if (!processItem) continue;
+    TheAnubisProcessList->SetRunningProcess(processItem);
+    AnubisProcess::anbStatus st = processItem->GetStatus();
+    p = processItem->GetPriority(); 
+    switch (st)
+    {
+        case AnubisProcess::running:              
+        case AnubisProcess::waiting_for_event:
+        case AnubisProcess::waiting_for_condition:        // machine in a 'wait for' loop 
+        case AnubisProcess::waiting_for_completion:       // of a child process ('execute')
+          result = sup(p,result); 
+          break; 
+
+        default: 
+          break; 
+    }
+  }
+  return result; 
+} 
  
  
+/* computing the credit for running a machine */
+static U32 compute_credit(U8 M,   /* maximum of credit of all running machines */ 
+                          U8 L)   /* priority of the machine */
+{
+  /* the formula for M - 16 < L < M:  
+                      M - L
+       result = D(1 - -----)  =  ((D<<4) - D(M-L))>>4
+                        16
+                        
+     where D = default maximal credit (max_steps)
+           M = max priority of running processes
+           L = priority of process 
+  */ 
+#define D (max_steps)
+  int32 result; 
+  do {
+       if (L >= M)         result =  max_steps; 
+  else if (L <= (M - 16))  result = 0; 
+  else result = ((D<<4) - D*(M-L))>>4; 
+     } while(0); 
+#undef D
+  return (U32)result; 
+}                           
+
  
 /* The scheduler */ 
 void schedul(void)
@@ -723,6 +777,7 @@ void schedul(void)
   U32 running_machines; 
   U32 waiting_machines; 
   U32 waiting_for_completion_machines; 
+  U32 max_running_priority;    /* the maximum of the priority levels of all running (non sleeping) machines */ 
   U32 steps = 0;
   U32 activity = 0;
   U32 wmm, wsm, maf; 
@@ -770,6 +825,8 @@ void schedul(void)
     steps = 0;
     U32 nbProcess = TheAnubisProcessList->GetCount();
     AnubisProcess * processItem;
+    
+    max_running_priority = max_priority_of_runnings(); 
  
     //for (i = nbProcess - 1; i >= 0; i--)
     for (i = nbProcess - 1; i != ~(U32)0; i--) // i-- with i unsigned and i = 0 is 111111111...1111 = ~0
@@ -794,13 +851,20 @@ void schedul(void)
         case CM::AnubisProcess::machine_not_used:                                               
           break; 
  
-        case AnubisProcess::running:              
-          steps = processItem->RunMachine(max_steps) ;
+        case AnubisProcess::running:  
+#if 0              
+          { /* debugging tool */ 
+              U8 p = processItem->GetPriority(); 
+              U32 c = compute_credit(max_running_priority,p); 
+              if (p != 255) { printf("<%d|%d>",p,c); fflush(stdout); }
+          }
+#endif               
+          steps = processItem->RunMachine(compute_credit(max_running_priority,processItem->GetPriority())) ;
           break; 
  
         case AnubisProcess::waiting_for_event:
           processItem->SetStatus(AnubisProcess::running); 
-          steps = processItem->RunMachine(max_steps);    
+          steps = processItem->RunMachine(compute_credit(max_running_priority,processItem->GetPriority()));    
           break; 
  
         case AnubisProcess::waiting_for_condition:     // machine in a 'wait for' loop 
@@ -808,12 +872,12 @@ void schedul(void)
           if (timevalless(processItem->GetAlarm(),&current_time))
           {
             processItem->SetStatus(AnubisProcess::running); 
-            steps = processItem->RunMachine(max_steps);    
+            steps = processItem->RunMachine(compute_credit(max_running_priority,processItem->GetPriority()));    
           }
           break; 
  
         case AnubisProcess::waiting_for_completion:       // of a child process ('execute')
-          steps = processItem->RunMachine(max_steps); 
+          steps = processItem->RunMachine(compute_credit(max_running_priority,processItem->GetPriority())); 
           break; 
  
         case AnubisProcess::need_bigger_stack:    
@@ -1011,7 +1075,7 @@ void schedul(void)
         {
           //LOGERROR("CRITICAL ERROR: Main VM select() failed with error [%d].\n", LAST_SOCKET_ERROR);
           usleep(1000);	// this will ensure that we won't take all the CPU time if a socket is
-          // invalid (bug encountered on 2007-08-15 by CR)
+                        // invalid (bug encountered on 2007-08-15 by CR)
         }
 #else
         //              select(FD_SETSIZE,&rfds,NULL,NULL,alarm_set ? (&time_to_wait) : NULL);
@@ -1597,6 +1661,7 @@ int main(int argc, char **argv)
   AnubisProcess * currentProcess;
   /* create a new Anubis Process, the first one. */ 
   currentProcess = TheAnubisProcessList->CreateAnubisProcess((the_primary_module.byte_code)+8+(the_primary_module.starting_point), 
+      255,    /* priority of 'mother' process */
       TheAnubisAllocator); 
  
  
@@ -5754,7 +5754,70 @@ ci_decl(start)
  
   AnubisProcess * newProcess;
   newProcess = TheAnubisProcessList->
-    CreateAnubisProcess(MAM(m_IP)+6,                            /* new machine starting point */
+    CreateAnubisProcess(MAM(m_IP)+6,         /* new machine starting point (6 is the size of the 'start' instruction) */
+        MAM(m_priority),                     /* priority level of current process */
+        MAM(m_allocator));
+
+  //printf("[%d] Creating new process. Starting %d. PID = %d\n", MAM(m_pid), relative_IP(MAM(m_IP)+6), newProcess->GetPid());
+  if (!newProcess)
+    /* cannot start a new machine yet, retry at next run */
+  {
+    MAM(m_steps) = 0;
+    return;
+  }
+
+  /* the new machine has been started */
+#ifndef normal_machine
+#undef MAM(m_SP_begin)
+#endif
+  new_stack = newProcess->GetSPBegin();
+#ifndef normal_machine
+#define MAM(m_SP_begin) (MAM(m_SP_begin))
+#endif
+  new_stack[0] = 0;             /* last return */
+  for (i = d; i >= 1; i--)
+    new_stack[d-i+1] = *(MAM(m_SP)-i);
+
+#ifndef normal_machine
+#undef MAM(m_SP)
+#endif
+  newProcess->SetSP(new_stack + d + 1);
+#ifndef normal_machine
+#define MAM(m_SP) (MAM(m_SP))
+#endif
+
+  MAM(m_IP) = (U8 *)get32(2);
+}
+
+
+
+
+/* Format:        startp (U8)depth (U32)addr
+Size:          6
+
+This instruction  starts a new virtual machine.  The 'depth' argument is  the number of
+items which should be  copied from the top of the stack of  the current machine, to the
+stack of  the new machine.   These items are  just words. There  is no virtual  copy to
+perform. They have been already done by the instructions just before 'start'.
+
+The priority level (a Word8) is in R. 
+
+'addr' is the address  to which the current machine should jump  after starting the new
+machine.   The   new  machine   itself  executes  the   code  following   this  'start'
+instruction.
+
+ */
+ci_decl(startp)
+{
+  trace
+    U32 *new_stack = NULL;
+  U8 d = get8(1);
+  U8 i;
+
+  AnubisProcess * newProcess;
+  newProcess = TheAnubisProcessList->
+    CreateAnubisProcess(MAM(m_IP)+6,         /* new machine starting point (6 is the size of the 'start' instruction) */
+        MAM(m_R),                            /* priority level of new process */
         MAM(m_allocator));
  
   //printf("[%d] Creating new process. Starting %d. PID = %d\n", MAM(m_pid), relative_IP(MAM(m_IP)+6), newProcess->GetPid());
@@ -216,7 +216,7 @@ extern void serialize_float(double d, U8 *dest);
 struct Exec_Mod_struct {
   U32      flags;                 /* also indicates is primary or secondary ('mf_secondary_adm' in 'bytecode.h') */
   //U32      code_size; 
-  /* since version 1.13, the 'byte_code' field does not only contain only the code. 
+  /* since version 1.13, the 'byte_code' field does not contain only the code. 
      It is an actual byte array, i.e. has the following form: 
  
     +---------+---------+-------------------------------------------   
@@ -224,7 +224,7 @@ struct Exec_Mod_struct {
     +---------+---------+-------------------------------------------   
     0         4         8
  
-    This byte array contains its own size. This why the field 'code_size' has been removed. 
+    This byte array contains its own size. This is why the field 'code_size' has been removed. 
  
     An array of Exec_Mod_struct (see dynamic_module.cpp) contains all currently loaded modules. 
     Only the primary module is permanent, hence has its counter 'cnt' always at 0. 
@@ -1013,6 +1013,7 @@ void link_globals_and_relocate(U8* code,
       case i_mvar_slots_del_mixed:
       case i_indirect_del_mixed:
       case i_start:
+      case i_startp:
       case i_type_mixed:
       case i_indirect_type_mixed:
           if (nsc_file != NULL)
  
-minnum = 13
-relnum = 5
+minnum = 14
+relnum = 0
 bldnum = 0
  
 package: