// $Source$
// $Revision$
// $Date$

$use Access Arithm Box Class Compare StdIO Table;

$table Empty-Table;

RFP-Clear-Table s.tbl =
/*
  <Domain s.tbl> :: e.keys,
  {
    e.keys : e (e.key) e, <Unbind s.tbl e.key>, $fail;;
  };
*/
  <Replace-Table s.tbl &Empty-Table>;

RFP-Debug? =
  <In-Table? &RFP-Options DEBUG>;

RFP-Double-Copy s.tab =
  <Table> :: s.new-tab,
  {
    <Domain s.tab> : e (e.key) e,
      <Lookup s.tab e.key> : s.tab1,
      <Bind s.new-tab (e.key) (<Table-Copy s.tab1>)>,
      $fail;
    s.new-tab;
  };

RFP-Double-Unbind s.tab e.keys =
  {
    e.keys : e t.key e,
      <Unbind s.tab t.key>,
      $fail;;
  };

RFP-Extract-Qualifiers {
  (e1 s2 s3 e4), <Int? s3> = (e1) s2 s3 e4;
  (e1 s2) = (e1) s2;
};

Del-Pragmas {
  eL t.Item eR, t.Item : \{
    (PRAGMA e) = eL <Del-Pragmas eR>;
    (expr) = eL (<Del-Pragmas expr>) <Del-Pragmas eR>;
  };
  e1 = e1;
};

/*
 * e.patterns -- set of terms t1 t2 ... tN,
 * e.replaces -- set of corresponding replacements in the form
 *   (e.repl1) (e.repl2) ... (e.replN).
 * Function substitutes e.replI for each occurence of tI in expr.
 * Sets are considered undirected, so function can fall in cycle, given input
 * such as (A B) ((B) (A)) A, or even (A) ((A)) A.
 */
Subst (e.patterns) (e.replaces) expr, {
  expr : e1 t2 e3, \{
    e.patterns : $r e4 t2 e5 =
      <L <Length e4> e.replaces> : (e6),
      e1 (e6 e3);
    t2 : (e7) =
      <Subst (e.patterns) (e.replaces) e7> : {
        e7 = e1 t2 (e3);
        e8 = e1 ((e8) e3);
      };
  } :: e9 (e10) =
    e9 <Subst (e.patterns) (e.replaces) e10>;
  expr;
};

/*
 * Search for e.pattern in expr (in all depths).
 */
In? \{
  (e.pattern) e e.pattern e;
  (e.pattern) e (expr) e, <In? (e.pattern) expr>;
};