Changeset 769


Ignore:
Timestamp:
May 28, 2003, 7:09:18 AM (18 years ago)
Author:
orlov
Message:
  • Some work on clashes.
  • FOR format in ASAIL is changed.
  • Gathering flatness information.
Location:
to-imperative/trunk/compiler
Files:
5 edited

Legend:

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

    r759 r769  
    7777      ('if (' <Cond-To-CPP e.cond> ')')
    7878      ('{' (<ASAIL-To-CPP e.body>) '}');
    79     (FOR (e.label) (e.cond) (e.step) e.body) =
    80       {
    81         e.label : t = (LABEL <Rfp2Cpp (LABEL e.label)> ': {}');;
    82       } :: e.label,
    83       ('for ( ; ' <Cond-To-CPP e.cond> '; ' <Step-To-CPP e.step> ')')
    84 //      ('{' ('{' (<ASAIL-To-CPP e.body>) '}') e.label '}');
    85       ('{' (<ASAIL-To-CPP e.body>) '}');
     79    (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body) =
     80      {
     81        e.cont-label : t =
     82          ('{'
     83            ('{' (<ASAIL-To-CPP e.body>) '}')
     84            (LABEL <Rfp2Cpp (LABEL e.cont-label)> ': {}')
     85          '}');
     86        ('{' (<ASAIL-To-CPP e.body>) '}');
     87      } :: e.body,
     88      {
     89        e.break-label : t = (LABEL <Rfp2Cpp (LABEL e.break-label)> ': {}');;
     90      } :: e.break,
     91      ('for ( ; ' <Cond-To-CPP e.cond> '; ' <Step-To-CPP e.step> ')') e.body e.break;
    8692    (LABEL (e.label) e.body) =
    8793      {
     
    122128      (<Rfp2Cpp t.var> '.drop ();');
    123129    (CONTINUE t.label) =
    124 //      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
    125       ('continue;');
     130      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
    126131    (BREAK t.label) =
    127132      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
     
    234239    <Expr-Ref-To-CPP e.expr> '.flat_at ('
    235240      <Expr-Int-To-CPP e.pos> ', ' <Expr-Int-To-CPP e.len> ')';
     241  (CHECK-ITER t.var) =
     242    'iter(' <Rfp2Cpp t.var> ')';
    236243  /*
    237244   * EQ -> to function eq() with 6 arg.
  • to-imperative/trunk/compiler/rfp_clashes.rf

    r759 r769  
    256256
    257257Get-Cycle =
    258   <? &Clashes> : e (s.idx (e.Re) (s.dir e.Pe) e.b1 &Unknown-Lengths e.b2) e.rest,
     258  <? &Clashes> : e (s.idx (e.Re) (s.dir e.Pe) e.b1 &Unknown-Lengths e.b2) e.rest =
    259259  <Prepare-Source e.Re> :: t.var,
     260  <Get-Known-Length t.var> : e.len (),
     261  <Lookup &Hard-Parts s.idx> : (e.left) (e.right) e.expr,
    260262  s.dir : {
    261263    LEFT =
    262       e.Pe : t.var-e1 e.Pe-rest,
    263       <Gener-Vars ((VAR)) "lsplit_" t.var> : t.var-e2,
    264       <Set-Var (Instantiated? True) t.var-e1>,
    265       <Set-Var (Instantiated? True) t.var-e2>,
    266       <Store &Clashes <Compose-Clashes (t.var-e2) (s.dir e.Pe-rest)> e.rest>,
    267       <Get-Var Clashes t.var-e1> :: e.clashes,
    268       <Map &Reclassify-Clash (<Sub (e.clashes) <? &Checked-Lengths>>)> : e,
    269       t.var t.var-e1 t.var-e2;
    270   };
    271 
    272 
     264      e.expr : t.var-e1 e.Pe-rest,
     265      t.var-e1 "lsplit_" e.Pe-rest;
     266    RIGHT =
     267      e.expr : e.Pe-rest t.var-e1,
     268      t.var-e1 "rsplit_" e.Pe-rest;
     269  } :: t.var-e1 s.pref-e2 e.Pe-rest,
     270  {
     271    <Var? e.Pe-rest> = e.Pe-rest ();
     272    <Gener-Vars ((VAR)) s.pref-e2 t.var> : t.var-e2,
     273      t.var-e2 ((t.var-e2) (s.dir e.Pe-rest));
     274  } : t.var-e2 (e.clash),
     275  {
     276    <Flat? e.Re> = (Flat? True);;
     277  } :: e.flat?,
     278  <Set-Var (Instantiated? True) e.flat? t.var-e1>,
     279  <Set-Var (Instantiated? True) e.flat? t.var-e2>,
     280  <Store &Clashes <Compose-Clashes e.clash> e.rest>,
     281  <Get-Var Clashes t.var-e1> :: e.clashes,
     282  <Map &Reclassify-Clash (<Sub (e.clashes) <? &Checked-Lengths>>)> : e,
     283  (e.left) (e.right) (e.len) t.var t.var-e1 t.var-e2;
    273284
    274285
  • to-imperative/trunk/compiler/rfp_clashes.rfi

    r759 r769  
    2525
    2626
    27 $func? Get-Cycle = t.var t.left t.right;
     27$func? Get-Cycle = (e.left) (e.right) (e.len) t.var t.left t.right;
    2828
    2929
  • to-imperative/trunk/compiler/rfp_compile.rf

    r759 r769  
    526526    <Pop-Snt-State>,
    527527    <Comp-Sentence Notail (v.fails) () e.body t.format> :: e.comp-body,
    528     (LABEL (t.exit)
    529       (FOR () () () (LABEL (t.label) e.comp-condition (BREAK t.exit)) e.comp-body)
     528    (FOR (/*cont-label*/) (t.exit) () ()
     529      (LABEL (t.label) e.comp-condition (BREAK t.exit)) e.comp-body
    530530    );
    531531
     
    769769
    770770Comp-Assign-to-Var (t.var (e.Re)) =
    771   <Set-Var (Instantiated? True) t.var>,
     771  {
     772    <Flat? e.Re> = (Flat? True);;
     773  } :: e.flat?,
     774  <Set-Var (Instantiated? True) e.flat? t.var>,
    772775  {
    773776    t.var : e.Re = /*empty*/;
     
    10631066  e.Re : /*empty*/;
    10641067
    1065 
    10661068$func CC s.tail? (v.fails) t.end-cycle e.Snt = e.asail-Snt;
    10671069
     
    10991101          (e.assign) v.clshs =
    11001102            <Map &Reclassify-Clash (v.clshs)> : e,
    1101             e.conds e.assign <CC s.tail? (v.fails) t.end-cycle e.Snt>;
     1103            e.conds e.assign
     1104            <CC s.tail? (v.fails) t.end-cycle e.Snt>;
    11021105          () /*empty*/ =
    11031106            e.conds <CC-Eqs <R 0 v.fails> () <? &Eqs>> :: e.actions,
     
    11051108            e.actions <CC-Compose-And-Compare <R 0 v.fails>> :: e.actions,
    11061109            {
    1107               <Get-Cycle> :: t.var t.l-var t.r-var =
    1108                 <Gener-Label L "For" "Cont"> :: t.cont-label,
    1109                 <Gener-Label L "For" "Break"> :: t.break-label,
    1110                 e.actions
     1110              <Get-Cycle>
     1111              :: (e.left) (e.right) (e.len) t.var t.l-var t.r-var =
     1112                {
     1113                  e.left : 0, e.right : 0 = /*empty*/ t.var;
     1114                  <Gener-Vars ((VAR)) "subexpr_" t.var> : t.sub-var,
     1115                    (SUBEXPR t.sub-var t.var (e.left)
     1116                      ((INFIX "-" (e.len) (e.left e.right))))
     1117                    t.sub-var;
     1118                } :: e.subexpr t.var,
     1119                <Gener-Label "continue"> :: t.cont-label,
     1120                <Gener-Label "exit"> :: t.break-label,
     1121                e.actions e.subexpr
    11111122                (LSPLIT t.var (<Get-Var Min t.l-var>) t.l-var t.r-var)
    1112                 (LABEL (t.break-label)
    1113                   (FOR (t.cont-label) () ((INC-ITER t.var))
    1114                     <CC s.tail? (v.fails ((CONTINUE t.cont-label)))
    1115                       <R 0 v.fails> e.Snt>
    1116                     (BREAK t.break-label)
    1117                   )
     1123                (FOR (t.cont-label) (t.break-label) () ((INC-ITER t.var))
     1124                  (IF ((NOT (CHECK-ITER t.var))) <Concat <R 0 v.fails>>)
     1125                  <CC s.tail?   (v.fails ((CONTINUE t.cont-label)))
     1126                    <R 0 v.fails> e.Snt>
     1127                  (BREAK t.break-label)
    11181128                );
    11191129              e.actions <Comp-Sentence s.tail? (v.fails) () e.Snt>;
     
    12101220};
    12111221
    1212 $func? Flat? e.Re = ;
    1213 
    1214 Flat? term =
    1215   \{
    1216     <Get-Var Flat? term> : True;
    1217     term : \{
    1218       (REF e) = term;
    1219       (STATIC e) = <Get-Static term>;
    1220     } :: e.Re,
    1221       <Flat-Const? e.Re>;
    1222   };
     1222Flat? {
     1223  term e.rest =
     1224    \{
     1225      <Get-Var Flat? term> : True;
     1226      term : \{
     1227        (REF e) = term;
     1228        (STATIC e) = <Get-Static term>;
     1229      } :: e.Re,
     1230        <Flat-Const? e.Re>;
     1231    },
     1232    <Flat? e.rest>;
     1233  /*empty*/;
     1234};
    12231235
    12241236CC-Deref (e.fail) e.actions, e.actions : {
     
    12521264      } :: s.eq =
    12531265        {
    1254           s.eq : FLAT-EQ, <Flat? e.Re> =
     1266          s.eq : FLAT-EQ =
     1267            {
     1268              e.Re : term, <Var? term> = <Set-Var (Flat? True) term>;;
     1269            },
     1270            (IF ((NOT (FLAT-EQ (e.Re) (e.pos) (t.Pt) (0) (e.len)))) e.fail);
     1271          <Flat? e.Re> =
     1272            {
     1273              <Var? t.Pt> = <Set-Var (Flat? True) t.Pt>;;
     1274            },
    12551275            (IF ((NOT (FLAT-EQ (e.Re) (e.pos) (t.Pt) (0) (e.len)))) e.fail);
    12561276          (IF ((NOT (EQ (e.Re) (e.pos) (e.len) (t.Pt) (0) (e.len)))) e.fail);
     
    12631283      <Set-Var (Instantiated? True) t.Pt>,
    12641284        {
    1265           <Flat? e.Re> = <Set-Var (Flat? True) t.Pt>;;
     1285          <Flat? e.Re> = <Set-Var (Flat? True) t.Pt>;
     1286          e.Re : term, <Var? term>, <Get-Var Flat? t.Pt> : True =
     1287            <Set-Var (Flat? True) term>;;
    12661288        },
    12671289        <CC-Eqs (e.fail) (e.assigns (SUBEXPR t.Pt e.Re (e.pos) (e.len))) e.rest>;
     
    12781300      <CC-Compose-And-Compare (e.fail)>;;
    12791301  };
    1280 *       <Compose-Source-For-Compare> : (e.
    1281 
    1282 *                               {
    1283 *                                       <Comp-Cycle e.clashes> :: t.var t.l-var t.r-var e.clashes =
    1284 *                                               <Gener-Label L "For" "Cont"> :: t.cont-label,
    1285 *                                               <Gener-Label L "For" "Break"> :: t.break-label,
    1286 *                                               e.cond e.cond2 e.assigns
    1287 *                                               (LSPLIT t.var (<Get-Var Min t.l-var>) t.l-var t.r-var)
    1288 *                                               (LABEL (t.break-label)
    1289 *                                                       (FOR (t.cont-label) () ((INC-ITER t.var))
    1290 *                                                               <CC (e.clashes) s.tail?
    1291 *                                                                       (e.prev-fails (e.fail))
    1292 *                                                                       (Comp Fail ((CONTINUE t.cont-label))) e.Snt>
    1293 *                                                               (BREAK t.break-label)
    1294 *                                                       )
    1295 *                                               );
    1296 *                                       e.cond e.cond2 e.assigns
    1297 *                                       <Comp-Sentence s.tail? (e.prev-fails (e.fail)) () e.Snt>;
    1298 *                               };
    1299 *               };
    1300 *};
    13011302
    13021303
  • to-imperative/trunk/compiler/rfp_compile.rfi

    r759 r769  
    2222
    2323
     24
     25$func? Flat? e.Re = ;
     26
     27
     28
    2429$func? Lookup-Func t.Fname = s.linkage s.tag t.pragma (e.Fin) (e.Fout);
    2530
Note: See TracChangeset for help on using the changeset viewer.