// $Id$

$use Convert List;

$func Add-Env e.items (env) = e.items (env);
$func Gen-Debugs (e.in-result?) (e.debugs) e.items = (e.debugs) e.items;

$func Gener-Debug e.debugs = e.debug-calls;

Add-Debug e.items =
  <Add-Env e.items ()> :: e.items t,
  <Gen-Debugs () () e.items> :: t e.items,
  e.items;

Add-Env e.items (env), e.items : {
  (BRANCH t.p e.branch) e.rest =
    <Add-Env e.branch (env)> :: e.branch t,
    (BRANCH t.p e.branch) <Add-Env e.rest (env)>;
  (ITER (BRANCH t.p e.branch) (FORMAT t.fp e.format) t.tail) =
    <Add-Env e.format (env)> :: e.format (env2),
    <Add-Env (RESULT (PRAGMA)) e.branch (env2)> :: e.branch t,
    <Add-Env t.tail (env2)> :: e.tail t,
    (Comp-Debug t.p env)
    (Comp-Debug t.fp env)
    (ITER (BRANCH t.p e.branch) (FORMAT t.fp e.format) e.tail) (env);
  (s.tag t.p t.name) e.rest, s.tag : \{ EVAR; VVAR; SVAR; TVAR; } =
    {
      env : $r e (s.tag t t.name) e = env;
      env (s.tag t.p t.name);
    } :: env,
    (s.tag t.p t.name)
    <Add-Env e.rest (env)>;
  (e1 (PRAGMA e.p) e2) e.rest =
    <Add-Env e2 (env)> :: e2 (env2),
    (Comp-Debug (PRAGMA e.p) env)
    (e1 (PRAGMA e.p) e2) <Add-Env e.rest (env2)>;
  (e1) e.rest =
    <Add-Env e1 (env)> :: e1 (env),
    (e1) <Add-Env e.rest (env)>;
  t1 e.rest =
    t1 <Add-Env e.rest (env)>;
  /*empty*/ = (env);
};

Gen-Debugs (e.in-result?) (e.debugs) e.items, e.items : {
  e1 (Comp-Debug e.d) = <Gen-Debugs (e.in-result?) ((e.d) e.debugs) e1>;
  e1 (Comp-Debug e.d) (RESULT t.p e.r) =
    {
      e.r : /*empty*/ =
        <Gen-Debugs (e.in-result?) () e1>
        (RESULT t.p <Gener-Debug (e.d) e.debugs>);
      <Gen-Debugs (In-Result!) () e.r> :: (e) e.r,
        <Gen-Debugs (e.in-result?) () e1>
        (RESULT t.p <Gener-Debug (e.d)> e.r <Gener-Debug e.debugs>);
    };
  e1 (Comp-Debug e.d) (s.op t.p), s.op : \{ CUT; CUTALL; STAKE; FAIL; ERROR; } =
    <Gen-Debugs () () e1>
    <Gener-Debug (e.d)> (s.op t.p) (RESULT t.p <Gener-Debug e.debugs>);
  e1 (Comp-Debug e.d) (CALL t.p t.name e.r) =
    <Gen-Debugs (In-Result!) () e.r> :: (e) e.r,
    <Gen-Debugs (In-Result!) () e1>
    (CALL t.p t.name e.r <Gener-Debug (e.d)>);
  e1 (e2) =
    <Gen-Debugs (e.in-result?) (e.debugs) e2> :: (e.debugs) e2,
    <Gen-Debugs (e.in-result?) (e.debugs) e1> (e2);
  e1 t2 =
    <Gen-Debugs (e.in-result?) (e.debugs) e1> t2;
  /*empty*/ = (e.debugs);
};

$func Conv-Var t.var = t.converted-var;
Conv-Var t.var =
  t.var : (t t (e.name)) = (PAREN <To-Chars e.name> (PAREN t.var));
 
$func Conv-Pragma t = e;
Conv-Pragma {
  ((PRAGMA (FILE e.file) (LINE s.line s.col)) env) =
    (BRANCH (PRAGMA) (RESULT (PRAGMA) (CALL (PRAGMA) (Debug Stop?) e.file s.line s.col)));
  t = /*empty*/;
};

Gener-Debug {
  v.debugs =
    v.debugs : (t.pragma env) e,
    <Map &Conv-Pragma (<Nub v.debugs>)> : {
      v.stop-cals =
        (BLOCK (PRAGMA) (BRANCH (PRAGMA)
            (BLOCK? (PRAGMA) v.stop-cals)
            (RESULT (PRAGMA) (CALL (PRAGMA) (Debug Debug) <Map &Conv-Var (env)>)))
          (BRANCH (PRAGMA) (RESULT (PRAGMA))));
      empty = empty;
    };;
};

// Sveta: //  creating of label for debug
// Sveta: 
// Sveta: $use "rfpc";         //  rfpc.rfi  
// Sveta: $use "rfp_lex";      // rfp_lex.rfi 
// Sveta: $use "rfp_parse";    // rfp_parse.rfi 
// Sveta: $use "rfp_compile";  // rfp_compile.rfi
// Sveta: $use "rfp_format";   // rfp_format.rfi
// Sveta: $use "rfp_src";
// Sveta: 
// Sveta: 
// Sveta: $use Box ;
// Sveta: $use Convert ;
// Sveta: $use Table ;
// Sveta: $use StdIO ;
// Sveta: $use Arithm ;
// Sveta: $use Access;
// Sveta: 
// Sveta: $func Debug-Call e.pos = e.debug;
// Sveta: //  $func Debug s.id e.names = e.Debug ;
// Sveta: $func Push-Vars  = ;
// Sveta: $func Pop-Vars = ;
// Sveta: $func Add-Vars t.var = ;
// Sveta: $func Get-Vars-Str  e.list = e.result;
// Sveta: $func Get-Vars e.list = e.vars;
// Sveta: $func Names-List t.pragma ex = ey;
// Sveta: $func AS-To-Ref e.as = e.rf;
// Sveta: $func Save-Id s.id (e.pos) = ;
// Sveta: $func Add-Pragma t.pragma e.list = e.vars;
// Sveta: $func Debug-Sent e.sentence = e.Debug;
// Sveta: $func Debug-Result e.result = e.Debug;
// Sveta: $func Debug-Hard e.hard = e.Debug;
// Sveta: $func Debug-Module e.module = e.Debug;
// Sveta: $func Store-Pragma e.pragma = ;
// Sveta: $func Debug-Pattern e.pattern = e.Debug; 
// Sveta: $func Debug-Call-Pattern t.pragma = e.Debug;
// Sveta: $func Debug-Add e.sent = e.Debug;
// Sveta: $func Format-Hard t.pragma e.expr = e.format;
// Sveta: $func? Debug-Lib /*empty*/ = e.lib;
// Sveta: $func? Try-Open e.path = e.dir;
// Sveta: $func Get-Ready-To-Work e.lib = e.ImportLib;
// Sveta: $func Correct-Tab-Sources s.tab e.key = ;
// Sveta: $func Def-Key s.key = s.new;
// Sveta: 
// Sveta: $box Debug-id;
// Sveta: $box Vars;
// Sveta: $box Pragma;    //  (e.filename) s.line s.col
// Sveta: $box HardExpr;  // result format for :: 
// Sveta: $box Numb;     // for unical "_debug"
// Sveta: 
// Sveta: $table Id-Position;
// Sveta: 
// Sveta: //RFP-Debug ex = <PrintLN "Debug : "ex '\n'>, ex :
// Sveta: //{
// Sveta: //  t.Syntax e.rest = t.Syntax : {
// Sveta: //    (MODULE t.Module e.ModuleBody) = <Push-Vars> 
// Sveta: //      (MODULE t.Module <Debug-Module e.ModuleBody>)<Pop-Vars>;                              
// Sveta: //    (INTERFACE e.body)  = t.Syntax;
// Sveta: //  } :: e.debug, e.debug <RFP-Debug e.rest>;
// Sveta: //  /*empty*/;
// Sveta: // };
// Sveta: 
// Sveta: RFP-Debug  e.module = { 
// Sveta:   <Table-Copy &RFP-Sources> :: s.tab,
// Sveta:   <Debug-Lib> <Correct-Tab-Sources s.tab <Domain s.tab>>  
// Sveta:   <Push-Vars> <Store &Debug-id 0>
// Sveta:   <Debug-Module e.module> <Pop-Vars>;
// Sveta:   e.module ;
// Sveta: };
// Sveta: 
// Sveta: Correct-Tab-Sources s.tab e.sources = e.sources : {
// Sveta:   /*empty*/;
// Sveta:   (s.key) e.rest = <Def-Key s.key> :: s.idx,  
// Sveta:     <Bind &RFP-Sources (s.idx) (<Lookup s.tab s.key>) > <Correct-Tab-Sources s.tab e.rest>;
// Sveta: };  
// Sveta: 
// Sveta: Def-Key s.key = {
// Sveta:   <In-Table?  &RFP-Sources s.key> = <Def-Key <"+" s.key 1> >;
// Sveta:   s.key;                  
// Sveta: }; 
// Sveta: 
// Sveta: Debug-Module 
// Sveta: {
// Sveta:   /*empty*/;
// Sveta:   t.item e.rest = t.item : (s.type e.body),  
// Sveta:   {
// Sveta:     s.type : PRAGMA = t.item;   
// Sveta:     s.type : IMPORT,   
// Sveta:     {
// Sveta:       e.body : s.objtype t.pragma t.objname, 
// Sveta:       { 
// Sveta:          t.objname : CHANNEL = t.item;
// Sveta: // ToDo    <Add-Vars t.objname> 
// Sveta:          t.item; 
// Sveta:       };
// Sveta:       t.item;     
// Sveta:     }; 
// Sveta:     s.type: \{ LOCAL; EXPORT; }, e.body : {
// Sveta:       CONST e.const = t.item;
// Sveta:       s.tag t.pragma t.fname t.input t.output e.sent = <Push-Vars>
// Sveta:          (s.type s.tag t.pragma t.fname t.input t.output <Debug-Sent e.sent>)
// Sveta:          <Pop-Vars>;
// Sveta:       s.objtype t.pragma t.objname = 
// Sveta:       {
// Sveta:          t.objname : CHANNEL = t.item;
// Sveta: // ToDo    <Add-Vars t.objname> 
// Sveta:           t.item;
// Sveta:       };
// Sveta:     }; 
// Sveta:   } :: e.debug, e.debug <Debug-Module e.rest>;
// Sveta: }; 
// Sveta: 
// Sveta: Debug-Sent  
// Sveta: {
// Sveta:   /*empty*/ ;
// Sveta:   (RESULT (PRAGMA) e.expr) e.rest = (RESULT (PRAGMA) e.expr)
// Sveta:     <Debug-Sent e.rest>; 
// Sveta: //  (RESULT (EVAR (PRAGMA) e.var) e.expr) e.rest =
// Sveta: //    (RESULT (EVAR (PRAGMA) e.var) e.expr) <Debug-Sent e.rest>;
// Sveta:   (RESULT t.pragma e.expr) e.rest =  
// Sveta: //   { e.rest : /*empty*/ = <Debug-Call><Store-Pragma t.pragma>
// Sveta: //     (RESULT t.pragma <Debug-Result e.expr>) <Debug-Call-Pattern t.pragma > ;
// Sveta:     <Debug-Call>  
// Sveta:     <Store-Pragma t.pragma>   
// Sveta:       (RESULT t.pragma <Debug-Result e.expr>) <Debug-Add e.rest>;
// Sveta: //  };
// Sveta:   t.stat e.rest = t.stat :
// Sveta:   {
// Sveta:     (PRAGMA e.pragma) = t.stat;
// Sveta: //    (FORMAT (EVAR (PRAGMA) e.var)) = t.stat;
// Sveta:     (FORMAT t.pragma e.hard)  = (FORMAT t.pragma <Debug-Hard e.hard>);   
// Sveta:     (NOT t.branch)  = (NOT <Debug-Sent t.branch>) ;
// Sveta:     (ITER e.sent)  = (ITER <Debug-Sent e.sent>) ;
// Sveta:     (TRY t.try e.Nofail t.catch) = 
// Sveta:       (TRY <Debug-Sent t.try> e.Nofail <Debug-Sent t.catch>);
// Sveta:     (CUT) = t.stat;
// Sveta:     (CUTALL t.pragma) = t.stat;
// Sveta:     (STAKE) = t.stat;
// Sveta:     (FAIL t.pragma) = <Debug-Call t.pragma> t.stat;
// Sveta:     (ERROR t.pragma) = <Store-Pragma t.pragma> t.stat;
// Sveta:     (NOFAIL) = t.stat;
// Sveta:     (BLOCK t.pragma e.branch) = <Push-Vars> <Store-Pragma t.pragma>
// Sveta:       (BLOCK t.pragma <Debug-Sent e.branch>) <Pop-Vars>;
// Sveta:     (BLOCK? t.pragma e.branch) = <Push-Vars>  <Store-Pragma t.pragma>
// Sveta:       (BLOCK? t.pragma <Debug-Sent e.branch>) <Pop-Vars>;
// Sveta:     (BRANCH t.pragma e.sent) = <Push-Vars> <Store-Pragma t.pragma>
// Sveta: //      (BRANCH t.pragma <Debug-Sent e.sent> <Debug-Call>) <Pop-Vars>;
// Sveta:         (BRANCH t.pragma <Debug-Sent e.sent>) <Pop-Vars>;
// Sveta:     (BRANCH? t.pragma e.sent) = <Push-Vars> <Store-Pragma t.pragma> 
// Sveta: //    (BRANCH? t.pragma <Debug-Sent e.sent> <Debug-Call>) <Pop-Vars> ;
// Sveta:        (BRANCH? t.pragma <Debug-Sent e.sent>) <Pop-Vars>;
// Sveta:     (LEFT t.pragma e.expr) = (LEFT t.pragma <Debug-Pattern e.expr>);
// Sveta:     (RIGHT t.pragma e.expr) = (RIGHT t.pragma <Debug-Pattern e.expr>);
// Sveta:   } :: e.debug, e.debug <Debug-Sent e.rest>;
// Sveta: };
// Sveta: 
// Sveta: Debug-Add e.sent = e.sent : { 
// Sveta: /*empty*/ = ;
// Sveta: (FORMAT t.pragma e.expr) e.rest = <Store &Numb 1>
// Sveta:   <Store &HardExpr <Format-Hard t.pragma e.expr>> 
// Sveta:   <Debug-Call-Pattern t.pragma> <Debug-Sent e.sent>;
// Sveta: (BLOCK t.pragma e.expr) e.rest = <Debug-Call-Pattern t.pragma>
// Sveta:   <Debug-Sent e.sent>;
// Sveta: (BLOCK? t.pragma e.expr) e.rest = <Debug-Call-Pattern t.pragma>
// Sveta:   <Debug-Sent e.sent>;
// Sveta: (LEFT t.pragma e.expr) e.rest = <Debug-Call-Pattern t.pragma>
// Sveta:   <Debug-Sent e.sent>;
// Sveta: (RIGHT t.pragma e.expr) e.rest = <Debug-Call-Pattern t.pragma>
// Sveta:   <Debug-Sent e.sent>;
// Sveta: e.sent = <Debug-Sent e.sent>;
// Sveta: };
// Sveta: 
// Sveta: Format-Hard t.pragma e.expr = e.expr : {
// Sveta: /*empty*/ = ;
// Sveta: t1 e.rest = t1: {
// Sveta:   s.sym = (SVAR t.pragma ("_debug_" <To-Word <? &Numb>>));
// Sveta:   (PAREN e.hard) = (PAREN <Format-Hard t.pragma e.hard>);
// Sveta:   (e.type t.var-pragma t.name) = 
// Sveta:     (e.type t.pragma ("_debug_" <To-Chars <? &Numb>>));
// Sveta:   } :: e.format, 
// Sveta:   <? &Numb> : s.num, <Store &Numb <"+" s.num 1>>, 
// Sveta:   e.format <Format-Hard t.pragma e.rest>;
// Sveta: };
// Sveta: 
// Sveta: Debug-Pattern 
// Sveta: {
// Sveta:   (PAREN e.pat) = (PAREN <Debug-Pattern e.pat>);
// Sveta:   (e.type t.pragma t.name) = 
// Sveta:     (e.type t.pragma t.name) <Add-Vars (e.type t.name)>;
// Sveta:   e.expr = e.expr;
// Sveta: };
// Sveta: 
// Sveta: Store-Pragma {
// Sveta:  (PRAGMA (FILE e.file) (LINE s.line s.col)) = <Store &Pragma (e.file) s.line s.col>;
// Sveta: };
// Sveta: 
// Sveta: Debug-Result 
// Sveta: {
// Sveta:   /*empty*/;
// Sveta:   t.res e.rest = t.res :
// Sveta:   {
// Sveta:     s1 = s1;
// Sveta:     (PAREN e.expr) = (PAREN <Debug-Result e.expr>);
// Sveta:     (REF t.name) = t.res;
// Sveta:     (CALL t.pragma t.name e.expr) = (CALL t.pragma t.name <Debug-Result e.expr>);
// Sveta:     (BLOCK t.pragma e.branch) = <Push-Vars> <Store-Pragma t.pragma>
// Sveta:       (BLOCK t.pragma <Debug-Sent e.branch>)<Pop-Vars>;
// Sveta:     (BLOCK? t.pragma e.branch) = <Push-Vars> <Store-Pragma t.pragma>
// Sveta:       (BLOCK? t.pragma <Debug-Sent e.branch>) <Pop-Vars>;
// Sveta:     (e.type t.pragma t.name) = 
// Sveta:       <Add-Vars (e.type t.name)> t.res;     
// Sveta:   } :: e.debug, e.debug <Debug-Result e.rest>;
// Sveta: };
// Sveta: 
// Sveta: Debug-Hard 
// Sveta: {
// Sveta:   /*empty*/ =  ;
// Sveta:   t.hard e.rest = t.hard :
// Sveta:   {
// Sveta:     s1 = s1;
// Sveta:     (PAREN e.expr) = (PAREN <Debug-Hard e.expr>);
// Sveta:     (e.type t.pragma t.name) =  
// Sveta:       <Add-Vars (e.type t.name)> t.hard;
// Sveta:   } :: e.debug, e.debug <Debug-Hard e.rest>;
// Sveta: };
// Sveta: 
// Sveta: Debug-Call  {
// Sveta: /*empty*/ = 
// Sveta:      <? &Pragma> : (e.file) s.line s.col,
// Sveta:        <"+" s.col 1> :: s.col,  
// Sveta:        (e.file) s.line s.col :: e.pos,
// Sveta:        <Store &Pragma e.pos>,
// Sveta:        (PRAGMA (FILE e.file) (LINE s.line s.col)) :: t.pragma,
// Sveta:        <? &Debug-id> : s.id,
// Sveta:        <Store &Debug-id <"+" s.id 1>>,
// Sveta:        <Bind &Id-Position (s.id) (e.pos)>,
// Sveta:        (BLOCK t.pragma
// Sveta:          (BRANCH t.pragma
// Sveta:             (RESULT t.pragma
// Sveta:              (CALL t.pragma ("Debug" "Debug-Check") s.id)
// Sveta:              (CALL t.pragma ("Debug" "Debug")<Get-Vars-Str t.pragma <? &Vars>>)
// Sveta:             )
// Sveta:           )
// Sveta:           (BRANCH t.pragma (RESULT t.pragma))
// Sveta:        );  
// Sveta: //     <Debug s.id e.pos>;
// Sveta: t.pragma = t.pragma : (PRAGMA (FILE e.file)(LINE s.line s.col)),
// Sveta:     (e.file) s.line s.col :: e.pos,
// Sveta:     <? &Debug-id> : s.id,
// Sveta:     <Store &Debug-id <"+" s.id 1>>,
// Sveta:     <Bind &Id-Position (s.id) (e.pos)>,
// Sveta:     (BLOCK t.pragma
// Sveta:       (BRANCH t.pragma
// Sveta:          (RESULT t.pragma
// Sveta:            (CALL t.pragma ("Debug" "Debug-Check") s.id)
// Sveta:            (CALL t.pragma ("Debug" "Debug")  <Get-Vars-Str t.pragma <? &Vars>> ) 
// Sveta:          )
// Sveta:        )
// Sveta:        (BRANCH t.pragma (RESULT t.pragma))
// Sveta:     );
// Sveta: //  <Debug s.id e.pos >;
// Sveta: };
// Sveta: 
// Sveta: Debug-Call-Pattern t.pragma = 
// Sveta:   t.pragma : (PRAGMA (FILE e.file)(LINE s.line s.col)),
// Sveta:   (e.file) s.line s.col :: e.pos,
// Sveta:   <? &Debug-id> : s.id,
// Sveta:   <Store &Debug-id <"+" s.id 1>>,
// Sveta:   <Bind &Id-Position (s.id)(e.pos)>,
// Sveta:   <? &HardExpr> :: e.format,
// Sveta:   <Store &HardExpr /*empty*/ >,
// Sveta:   {  
// Sveta:     e.format : /*empty*/ = (EVAR t.pragma ("_debug_"));
// Sveta:     e.format;
// Sveta:   } :: e.format,
// Sveta:   (FORMAT t.pragma e.format)
// Sveta:   (BLOCK t.pragma
// Sveta:     (BRANCH t.pragma
// Sveta:       (RESULT t.pragma
// Sveta:         (CALL t.pragma ("Debug" "Debug-Check") s.id) 
// Sveta:         (CALL t.pragma ("Debug" "Debug") <Get-Vars-Str t.pragma <? &Vars>>)
// Sveta:       )
// Sveta:     )
// Sveta:     (BRANCH t.pragma (RESULT t.pragma)
// Sveta:     )
// Sveta:   )
// Sveta:   (RESULT t.pragma e.format);
// Sveta: 
// Sveta: // Call of Debug-Function with variant- parameters
// Sveta: // Debug s.id e.pos = e.pos : (e.file) s.line s.col,  
// Sveta: //   <Save-Id s.id (e.idx s.line s.col)>
// Sveta: //     <PrintLN 's.id = 's.id ' e.pos= ' e.file
// Sveta: //     s.line s.col 'e.names ='<Names-List (e.pos) <Get-Vars <? &Vars>>> > ;
// Sveta: 
// Sveta: // new level of vars-stack is added
// Sveta: Push-Vars = <Store &Vars <? &Vars> () >;
// Sveta: 
// Sveta: // level of vars-stack is deleted
// Sveta: Pop-Vars  = <? &Vars> : e.var (e.last),
// Sveta:             <Store &Vars e.var>;
// Sveta: 
// Sveta: Add-Vars t.var =  // t.var = (e.type t.name)
// Sveta:   <? &Vars> :: e.list, e.list : {
// Sveta:      e1 ( e2 t.var e3) e4 = ;
// Sveta:      e1 (e.last) = <Store &Vars e1 (e.last t.var) >;
// Sveta:   };
// Sveta: 
// Sveta: Get-Vars 
// Sveta: { 
// Sveta:   /*empty*/ = /*empty*/;
// Sveta:    (e.head) e.tail = e.head <Get-Vars e.tail>;
// Sveta: };
// Sveta: 
// Sveta: Get-Vars-Str   
// Sveta: {
// Sveta:   t.pragma  = ;
// Sveta:   t.pragma (e.head) e.tail  =  { 
// Sveta:     e.head : /*empty*/  = <Get-Vars-Str  t.pragma e.tail>;
// Sveta:     <Names-List t.pragma e.head> <Get-Vars-Str t.pragma e.tail>;
// Sveta:   };
// Sveta: };
// Sveta: 
// Sveta: Add-Pragma t.pragma e.list = e.list :
// Sveta: {
// Sveta:   (s.type t.name) e.tail = (s.type t.pragma t.name) <Add-Pragma t.pragma e.tail>; 
// Sveta:    /*empty*/ = ;;
// Sveta: };
// Sveta: 
// Sveta: Names-List 
// Sveta: {  
// Sveta:    t.pragma  = /*empty*/;
// Sveta:    t.pragma t.var e.tail = (PAREN <To-Word <AS-To-Ref t.var>>) (PAREN <Add-Pragma t.pragma  t.var>) 
// Sveta:                   <Names-List t.pragma e.tail>;
// Sveta: };      
// Sveta: 
// Sveta: AS-To-Ref
// Sveta: {
// Sveta:   SVAR = 's';
// Sveta:   TVAR = 't';
// Sveta:   EVAR = 'e';
// Sveta:   VVAR = 'v';
// Sveta:   (s.tag (e.name)) = <AS-To-Ref s.tag> '.' <To-Chars e.name> ;
// Sveta: };
// Sveta: 
// Sveta: Save-Id s.idx (e.pos) = ;  // e.pos : e.filename s.line s.col
// Sveta: 
// Sveta: Try-Open {
// Sveta: /*empty*/ = <PrintLN "File of debug-library " &Name-Debug-File "  not found ">
// Sveta:    $fail;
// Sveta: (e.dir) e.rest = { 
// Sveta:   <Channel> :: s.ch,
// Sveta:   <Open-File s.ch e.dir &Dir-Separator &Name-Debug-File "r">,
// Sveta:   <Close-Channel s.ch>, 
// Sveta:   e.dir;
// Sveta:   <Try-Open e.rest>;
// Sveta:   };
// Sveta: };
// Sveta:  
// Sveta: Debug-Lib  =  <? &RFP-Include-Path> :: e.path, {
// Sveta:   <Try-Open e.path> :: e.dir,
// Sveta:   <RFP-Lexer e.dir &Dir-Separator &Name-Debug-File> :: e.source,
// Sveta:   <Store &RFP-Token-Stack e.source>,
// Sveta:   <RFP-Parser> : (INTERFACE t.name e.lib),      // Debug.rfi
// Sveta:   <Get-Ready-To-Work e.lib>;  
// Sveta:   $fail;
// Sveta: };
// Sveta: 
// Sveta: Get-Ready-To-Work  
// Sveta: {
// Sveta:   /*empty*/ ;
// Sveta:   t.Item e.rest =
// Sveta:     t.Item : (s.Linkage s.ItemType t.Pragma t.ItemName e.ItemBody),
// Sveta:     s.ItemType : {
// Sveta:       FUNC = <Left 0 2 e.ItemBody> : (e.in) (e.out),
// Sveta:         &Fun (<Format-Exp e.in>) (<Format-Exp e.out>);
// Sveta:       FUNC? = <Left 0 2 e.ItemBody> : (e.in) (e.out),
// Sveta:         &Fun? (<Format-Exp e.in>) (<Format-Exp e.out>);
// Sveta:     } :: s.tab e.ItemDef,
// Sveta:     <Bind s.tab (t.ItemName) (IMPORT s.ItemType t.Pragma e.ItemDef)>,
// Sveta:     (IMPORT s.ItemType t.Pragma t.ItemName e.ItemBody)
// Sveta:     <Get-Ready-To-Work e.rest>;
// Sveta: };