Changeset 1006


Ignore:
Timestamp:
Jul 12, 2003, 11:37:29 AM (17 years ago)
Author:
orlov
Message:
  • Implemented composition of sources for clashes.
  • Some silly bugs are fixed.
  • Some comments.
Location:
to-imperative/trunk/compiler
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/compiler/rfp_clashes.rf

    r924 r1006  
    3333 *
    3434 */
    35 $box Ready-Source;
    36 /*
    37  * Хранит просто номера клешей.  Означает, что правая часть клеша --
    38  * переменная, либо константное выражение, следовательно, над ней можно
    39  * производить разные операции, такие как взятие подвыражений, отщепления,
    40  * всевозможные проверки и т.п.
     35
     36
     37/*
     38 * Образец может иметь жёсткие по длине части слева и справа.  Сопоставление с
     39 * этими частями выливается в проверку условий возможности такого сопоставления
     40 * и заведение новых переменных.  Всё это делается до компиляции циклической
     41 * части образца.
    4142 *
    42  */
    43 
    44 
     43 * В результате означивания новых переменных, жёсткие части образца могут
     44 * удлинняться.  Следующая таблица по индексу клеша хранит запись вида:
     45 * (e.left) (e.right) expr.
     46 * e.left  -- выражение, в ран-тайм получающее значение длины жёсткой части
     47 * слева.
     48 * e.right -- аналогичное выражение для длины жёсткой части справа.
     49 * expr    -- часть выражения между жёсткими кусками.
     50 */
    4551$table Hard-Parts;
    4652
     53
     54$box Parenth1;
     55$box Parenth2;
    4756
    4857
     
    129138***************************** Инициализация ******************************
    130139
    131 $func Put-In e.clashes = ;  // президент такой был ;-)
     140$func Compose-Clashes e.clashes = e.clashes;
    132141
    133142Init-Clashes e.clashes =
    134   <Store &Clashes /*empty*/>,
    135143  <RFP-Clear-Table &Known-Lengths>,
    136144  <RFP-Clear-Table &Compute-Length>,
     
    138146  <Store &Checked-Lengths /*empty*/>,
    139147  <Store &Eqs /*empty*/>,
    140   <Store &Ready-Source /*empty*/>,
     148  <Store &Parenth1 /*empty*/>,
     149  <Store &Parenth2 /*empty*/>,
    141150  <RFP-Clear-Table &Hard-Parts>,
    142151  <Store &FreeIdx 0>,
    143   <Put-In e.clashes>;
    144 
    145 Put-In {
    146   (e.Re) (s.dir e.Pe) e.rest =
    147     /*
    148      */
    149     <Free-Index> :: s.idx,
    150     /*
    151      */
    152     <Classify-Lengths (s.idx (e.Re) (s.dir e.Pe))> :: e.boxes1,
    153     /*
    154      * Если e.R1 -- переменная или константа, кладём её в ящик
    155      * &Ready-Source.
    156      */
    157     {
    158       \{
    159         <Var? e.Re>;
    160         e.Re : (STATIC e);
    161         e.Re : (REF e);
    162       } =
    163         <Put &Ready-Source s.idx>,
    164         &Ready-Source;;
    165     } :: e.boxes2,
    166     /*
    167      * Распихав клеш по всем нужным ящикам, сохраняем его в таблице вместе
    168      * со ссылками на них.
    169      */
    170     <Put &Clashes (s.idx (e.Re) (s.dir e.Pe) e.boxes1 e.boxes2)>,
    171     <Put-In e.rest>;
    172   /*empty*/ = /*empty*/;
    173 };
    174 
    175 $func Compose-Clashes e.clashes = e.clashes;
     152  <Store &Clashes <Compose-Clashes e.clashes>>;
    176153
    177154Compose-Clashes {
     
    179156    <Free-Index> :: s.idx,
    180157    <Classify-Lengths (s.idx (e.Re) (s.dir e.Pe))> :: e.boxes,
     158    {
     159      \{
     160        <Get-Var Instantiated? e.Re> : True;
     161        e.Re : (REF e);
     162        e.Re : (STATIC e);
     163      };
     164      {
     165        e.Re : t = &Parenth1;
     166        &Parenth2;
     167      } :: s.box,
     168        {
     169          e.Pe : e1 (PAREN e) e2 =
     170            <Put s.box (s.idx (<Vars e.Re>) <Vars e1>)>,
     171            {
     172              e2 : $r e (PAREN e) e3 =
     173                <Put s.box (s.idx (<Vars e.Re>) <Vars e3>)>;;
     174            };;
     175        };
     176    },
    181177    (s.idx (e.Re) (s.dir e.Pe) e.boxes) <Compose-Clashes e.rest>;;
    182178};
     
    184180
    185181
     182
     183******* Обновление информации о жёстких началах и концах образцов ********
    186184
    187185$func UHP (e.conds) (e.assigns) e.clashes = e.clashes (e.actions);
     
    190188  e.clashes (e.conds) (e.assigns) (e.pos) (e.Pe);
    191189
     190/*
     191 * Просматриваем все имеющиеся клеши.
     192 * Если в результате новой информации о переменных, входящих в образец, можно
     193 * утверждать что жёсткие части удлиннились, запоминаем эту информацию в
     194 * таблице &Hard-Parts, заводим новые клеши, получающиеся из скобок в образце,
     195 * и возвращаем условия и присваивания, нужные, чтобы завести эти клеши.
     196 * Новые, входящие в жёсткие, части образца, не являющиеся скобками, кладутся в
     197 * ящик &Eqs вместе с результатным выражением и с позицией в этом выражении с
     198 * которой надо эти части сопоставлять.
     199 */
    192200Update-Hard-Parts =
    193201  <UHP () () <? &Clashes>> :: e.clashes (e.actions),
     
    214222    <Compose-Clashes e.l-clashes> t.clash <Compose-Clashes e.r-clashes>
    215223    <UHP (e.conds e.l-conds e.r-conds) (e.assigns e.l-assigns e.r-assigns) e.rest>;
     224  t.unready-clash e.rest = t.unready-clash <UHP (e.conds) (e.assigns) e.rest>;
    216225  /*empty*/ = (e.conds e.assigns);
    217   t.unready-clash e.rest = t.unready-clash <UHP (e.conds) (e.assigns) e.rest>;
    218 };
    219 
     226};
     227
     228/*
     229 * Функция, занимающаяся непосредственно проверкой составляющих образца на
     230 * вычислимость длин, начиная слева или справа, в зависимости от s.dir.
     231 *
     232 * Если очередной терм -- это скобки, то должен быть заведён новый клеш,
     233 * образованный из содержимого скобок.  Перед этим надо произвести проверку на
     234 * то, что в результатном выражении в этом месте тоже стоят скобки, и завести
     235 * переменную, обозначающую их содержимое.
     236 *
     237 * Данная функция возвращает всю информацию, необходимую для этих действий.
     238 */
    220239UHP-Clash s.dir s.fun s.l s.r (e.conds) (e.assigns) (e.pos) (e.Re) e.Pe, {
    221240  <Apply s.fun 0 e.Pe> : t.Pt, {
     
    241260
    242261
    243 $func Prepare-Source e.source = t.var;
    244 
    245 Prepare-Source t.var = t.var;
    246 
    247 
    248 
    249 
    250 Compose-Source-For-Deref = ();
    251 
    252 
    253 
     262$func Prepare-Source e.source = t.var e.assign;
     263
     264$func Define-Vars e.vars = e.eqs;
     265
     266Prepare-Source {
     267  t.Re =
     268    {
     269      \{
     270        <Get-Var Instantiated? t.Re> : True;
     271        t.Re : (REF e);
     272        t.Re : (STATIC e);
     273      } =
     274        t.Re /*empty*/;
     275      t.Re <Define-Vars t.Re>;
     276    };
     277  e.Re =
     278    <Gener-Vars ((EVAR)) "compose"> : t.var,
     279    <Set-Var (Instantiated? True) t.var>,
     280    <Vars-Decl t.var> : e, // ???
     281    t.var <Define-Vars <Vars e.Re>> (EXPR <Vars-Print t.var> e.Re);
     282};
     283
     284Define-Vars {
     285  t.var e.rest =
     286    {
     287      <Get-Var Instantiated? t.var> : True;
     288      <? &Eqs> : e1 (t.Re t.pos t.var t.len) e2 =
     289        <Store &Eqs e1 e2>,
     290        (t.Re t.pos t.var t.len) <Define-Vars e.rest>;
     291      <Set-Var (Instantiated? True) t.var>; // STUB!!!
     292    };
     293  /*empty*/ = /*empty*/;
     294};
     295
     296
     297
     298$func Find-SFD e.parenth = e.parenth (e.idx);
     299
     300Compose-Source-For-Deref =
     301  <Find-SFD <? &Parenth1>> :: e.parenth1 (e.idx),
     302  <Store &Parenth1 e.parenth1>,
     303  {
     304    e.idx : s.i = s.i;
     305    <Find-SFD <? &Parenth2>> :: e.parenth2 (e.idx),
     306      <Store &Parenth2 e.parenth2>,
     307      e.idx : s.i = s.i;
     308    /*else*/ = $fail;
     309  } :: s.idx,
     310  <? &Clashes> : e1 (s.idx (e.Re) (s.dir e.Pe) e) e2 =
     311  <Prepare-Source e.Re> :: t.var e.assign,
     312  <Store &Clashes e1 <Compose-Clashes (t.var) (s.dir e.Pe)> e2>,
     313  e.assign;
     314
     315$func? Not-Instantiated-Var e = e;
     316
     317Find-SFD {
     318  (s.idx (e.Re-vars) e.Pe-vars) e.rest =
     319    <Filter &Not-Instantiated-Var (e.Re-vars)> : {
     320      v.r-vars = (s.idx (v.r-vars) e.Pe-vars) <Find-SFD e.rest>;
     321      /*empty*/ = <Get-Known-Length e.Pe-vars> : {
     322        e (v.p-vars) = (s.idx () v.p-vars) <Find-SFD e.rest>;
     323        e () = e.rest (s.idx);
     324      };
     325    };
     326  /*empty*/ = ();
     327};
     328
     329Not-Instantiated-Var t.var = # \{
     330  <Get-Var Instantiated? t.var> : True;
     331  <? &Eqs> : e (t t t.var t) e;
     332};
    254333
    255334
     
    257336Get-Cycle =
    258337  <? &Clashes> : e (s.idx (e.Re) (s.dir e.Pe) e.b1 &Unknown-Lengths e.b2) e.rest =
    259   <Prepare-Source e.Re> :: t.var,
     338  <Prepare-Source e.Re> :: t.var e.assign,
    260339  <Get-Known-Length t.var> : e.len (),
    261340  <Lookup &Hard-Parts s.idx> : (e.left) (e.right) e.expr,
     
    278357  <Get-Var Clashes t.var-e1> :: e.clashes,
    279358  <Map &Reclassify-Clash (<Sub (e.clashes) <? &Checked-Lengths>>)> : e,
    280   (e.left) (e.right) (e.len) t.var t.var-e1 t.var-e2;
     359  e.assign (e.left) (e.right) (e.len) t.var t.var-e1 t.var-e2;
    281360
    282361
  • to-imperative/trunk/compiler/rfp_clashes.rfi

    r769 r1006  
    2222
    2323
    24 $func Compose-Source-For-Deref = e;
     24$func? Compose-Source-For-Deref = e.assign;
    2525
    2626
    27 $func? Get-Cycle = (e.left) (e.right) (e.len) t.var t.left t.right;
     27$func? Get-Cycle = e.assign (e.left) (e.right) (e.len) t.var t.left t.right;
    2828
    2929
  • to-imperative/trunk/compiler/rfp_compile.rf

    r963 r1006  
    775775      <Lookup &Prep-Vars e.prefix s.n>;
    776776      <Gener-Vars ((s.var-tag)) e.prefix> :: e.var,
    777 //        <WriteLN Prep-Var (s.var-tag (e.prefix s.n)) e.var>,
    778777        <Bind &Prep-Vars (e.prefix s.n) (e.var)>,
    779778        e.var;
     
    793792  {
    794793    t.var : e.Re = /*empty*/;
    795     <Generated-Var? e.Re>, # \{ <Get-Var Instantiated? t.var> : True; } =
     794    <Generated-Var? e.Re>,
     795      # \{ <Get-Var Instantiated? t.var> : True; },
     796      <Get-Var Decl e.Re> : s.box =
    796797      <Gener-Var-Assign t.var e.Re>;
    797798    <Set-Var (Instantiated? True) t.var>, $fail;
     
    11181119        <CC s.tail? (v.fails) t.end-cycle e.Snt>;
    11191120      /*empty*/ =
    1120         <Compose-Source-For-Deref> : {
    1121           (e.assign) v.clshs =
    1122             <Map &Reclassify-Clash (v.clshs)> : e,
    1123             e.conds e.assign
     1121        {
     1122          <Compose-Source-For-Deref> :: e.assign =
     1123            e.conds <CC-Eqs <R 0 v.fails> () e.assign>
    11241124            <CC s.tail? (v.fails) t.end-cycle e.Snt>;
    1125           () /*empty*/ =
    1126             e.conds <CC-Eqs <R 0 v.fails> () <? &Eqs>> :: e.actions,
    1127             <Store &Eqs /*empty*/>,
    1128             e.actions <CC-Compose-And-Compare <R 0 v.fails>> :: e.actions,
     1125          e.conds <CC-Compose-And-Compare <R 0 v.fails>> :: e.actions,
    11291126            {
    11301127              <Get-Cycle>
    1131               :: (e.left) (e.right) (e.len) t.var t.l-var t.r-var =
     1128              :: e.assign (e.left) (e.right) (e.len)
     1129                    t.var t.l-var t.r-var =
    11321130                {
    11331131                  e.left : 0, e.right : 0 = /*empty*/ t.var;
     
    11391137                <Gener-Label "continue"> :: t.cont-label,
    11401138                <Gener-Label "exit"> :: t.break-label,
    1141                 e.actions e.subexpr
     1139                e.actions
     1140                <CC-Eqs <R 0 v.fails> () e.assign> e.subexpr
    11421141                (LSPLIT t.var (<Get-Var Min t.l-var>) t.l-var t.r-var)
    11431142                (FOR (t.cont-label) (t.break-label) () ((INC-ITER t.var))
     
    12361235
    12371236Pos {
    1238   (e.Re) RIGHT e.pos = (INFIX "-" ((LENGTH e.Re)) ((e.pos)));
     1237  (e.Re) RIGHT e.pos = (INFIX "-" ((LENGTH e.Re)) (1) (e.pos));
    12391238  (e.Re) LEFT  e.pos = e.pos;
    12401239};
    12411240
     1241/*
     1242 * Информацию о проверках и заведении переменных, необходимых для создания
     1243 * клешей из содержимого скобок, кодируем на ASAIL.
     1244 */
    12421245CC-Deref (e.fail) e.actions, e.actions : {
    12431246  (SYMBOL? e.Re (s.dir e.pos)) e.rest =
     
    12881291        <CC-Eqs (e.fail) (e.assigns (SUBEXPR t.Pt e.Re (e.pos) (e.len))) e.rest>;
    12891292    };
    1290   e.assigns;
     1293  e.assigns e.eqs;
    12911294};
    12921295
    12931296CC-Compose-And-Compare (e.fail) =
    1294   <Update-Hard-Parts> : e,
    12951297  {
    12961298    <? &Eqs> : v.eqs =
    1297       <CC-Eqs (e.fail) () v.eqs>
    1298       <Store &Eqs /*empty*/>
    1299       <CC-Compose-And-Compare (e.fail)>;;
     1299      <CC-Eqs (e.fail) () v.eqs> :: e.actions,
     1300      <Store &Eqs /*empty*/>,
     1301      <Update-Hard-Parts> : e,
     1302      e.actions <CC-Compose-And-Compare (e.fail)>;;
    13001303  };
    13011304
  • to-imperative/trunk/compiler/rfp_format.rf

    r963 r1006  
    7272        <Split-Rt t.Ft t.Rt> <Split-Re (e.Fe) e.Re>;
    7373    };
    74   (v.Fe t.Ft) v.Re t.Rt,
     74  (v.Fe t.Ft) e.Re t.Rt,
    7575    \{
    7676      /*
     
    8181        <Format-Exp t.Rt> : (REF e);
    8282      } =
    83         <Split-Re (v.Fe) v.Re> <Split-Rt t.Ft t.Rt>;
     83        <Split-Re (v.Fe) e.Re> <Split-Rt t.Ft t.Rt>;
    8484    };
    8585  ((REF t.name) e.Fe) e.Re, {
  • to-imperative/trunk/compiler/rfp_lex.rf

    r683 r1006  
    6868$func? Interface-Name? e.source = e.iname ;
    6969
    70 $func Push-Source e.source s.row s.column = ;
     70$func Push-Source e.source s.type s.row s.column = ;
    7171$func? Pop-Source? = ;
    7272
  • to-imperative/trunk/compiler/rfp_vars.rfi

    r924 r1006  
    55$func? Var? expr = ;
    66$func Set-Var e.info t.var = ;
    7 $func? Get-Var t.key t.var = e.val;
     7$func? Get-Var t.key e.var = e.val;
    88$func Set-Var- e = e;
    99
Note: See TracChangeset for help on using the changeset viewer.