Changeset 2068


Ignore:
Timestamp:
Aug 24, 2006, 9:27:57 PM (14 years ago)
Author:
orlov
Message:
  • Again dancing around variables naming in as2as and asail2asail.
  • Fixed references to functions from $const-ants.
  • New rfp_lex.Find-Includes function (used in rfpj).
  • Parse all blocks as RESULTs (well, this part isn't really done yet --

resulting ASR isn't always compilable).

  • While generating Java: package name is computed from -I options.
  • In Java do exit(100) when uncaught $error comes (TODO the same in C++).
  • Uses of Repeat function are changed to List.Replicate.
  • Some other functions are gone from rfp_helper (Abs, Max, Min, L-, R-...).
Location:
to-imperative/trunk/compiler
Files:
13 edited

Legend:

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

    r2052 r2068  
    1919
    2020// remove blocks from Re
    21 $func Flatten-Result (e.Re) e.items = e.assigns (e.Re);
     21$func Flatten-Result s.tail? (e.Re) e.items = e.assigns (e.Re);
    2222
    2323$func Generate-In-Vars (e.in) e.branch = (e.in) e.branch;
     
    9090      e.branches : (BRANCH t.p e.branch) e.rest,
    9191        <Unstick-Blocks e.branch> :: e.new-branch (e.Fe),
    92         { e.Fe : FAIL; (e.Fe); } :: e.Fe,
    93         e.rest (e.br (BRANCH t.p e.new-branch)) (e.Fes e.Fe);
     92        e.rest (e.br (BRANCH t.p e.new-branch)) (e.Fes (e.Fe));
    9493    } :: e.branches (e.br) (e.Fes),
    9594    e.branches : /*empty*/ =
     
    103102        (RIGHT e) e;
    104103      } =
    105         <Gener-Var-Indices 1 (<MSG e.Fes>) "aux" "block"> :: e.aux s,
     104        <? &Free-Idx> : s.N,
     105        <Gener-Var-Indices s.N (<MSG e.Fes>) "aux" "alt"> :: e.aux s.N,
     106        <Store &Free-Idx s.N>,
    106107        eL (s.block t.Pragma e.br) (FORMAT (PRAGMA) e.aux)
    107108        (RESULT (PRAGMA) e.aux) <Unstick-Blocks eR>;
     
    110111      eL (s.block t.Pragma e.br) <Unstick-Blocks eR>;
    111112    };
     113  (RESULT t.Pragma (s.block e.branches)) eR, s.block : \{ BLOCK; BLOCK?; } =     // FIXME: Comment this and search for BUGs!
     114    eL <Unstick-Blocks (s.block e.branches) eR>;
    112115  (RESULT t.Pragma e.Re) eR =
    113     <Flatten-Result () e.Re> :: e.assigns (e.Re),
     116    <Flatten-Result Tail () e.Re> :: e.assigns (e.Re),
     117    {
     118      e.Re : e1 (FAIL e2) = (RESULT t.Pragma e1) e2;
     119      (RESULT t.Pragma e.Re);
     120    } :: e.Result,
    114121    {
    115122      eR : v =
    116         eL e.assigns (RESULT t.Pragma e.Re) <Unstick-Blocks eR>;
    117       eL e.assigns (RESULT t.Pragma e.Re) (<Format-Exp e.Re>);
     123        eL e.assigns e.Result <Unstick-Blocks eR>;
     124      <Format-Exp e.Re> :: e.Fe,
     125        <MSG (e.Fe) (e.Fe)> :: e.Fe,  // hack for avoiding non-hard formats
     126        eL e.assigns e.Result (e.Fe);
    118127    };
    119128  (NOT (BRANCH t.p1 e.body)) eR =
     
    128137    <Unstick-Blocks t.CatchBlock> :: e.CatchBlock t.Catch-Fe,
    129138    eL (TRY (BRANCH t.p1 e.TrySnt) e.NOFAIL e.CatchBlock) (<MSG t.Try-Fe t.Catch-Fe>);
    130   (FAIL e) = e.Sentence (FAIL);
     139  (FAIL e) = e.Sentence ((FAIL));
    131140  (ERROR t.Pragma) eR =
    132141    <Unstick-Blocks eR> :: eR t,
    133     eL (ERROR t.Pragma) eR (FAIL);
     142    eL (ERROR t.Pragma) eR ((FAIL));
    134143};
    135144
    136 Flatten-Result (e.Re) e.items, e.items : {
     145Flatten-Result s.tail? (e.Re) e.items, e.items : {
    137146  t1 e.rest, t1 : \{ (BLOCK e); (BLOCK? e); } =
    138     <Format-Exp e.Re> :: e.Fe,
    139     <MSG (e.Fe) (e.Fe)> :: e.Fe,  // hack for avoiding non-hard formats
    140     <? &Free-Idx> : s.N,
    141     <Gener-Var-Indices s.N (e.Fe) "aux" "result"> :: e.aux1 s.N,
    142     <Store &Free-Idx s.N>,
    143147    <Unstick-Blocks t1> :: e1 (e.Format),
    144     <? &Free-Idx> : s.N2,
    145     <Gener-Var-Indices s.N2 (e.Format) "aux" "block"> :: e.aux2 s.N2,
    146     <Store &Free-Idx s.N2>,
    147     (RESULT (PRAGMA) e.Re) (FORMAT (PRAGMA) e.aux1)
    148     e1 (FORMAT (PRAGMA) e.aux2)
    149     <Flatten-Result (e.aux1 e.aux2) e.rest>;
     148    {
     149      e.Format : (FAIL) =
     150        (e.Re (FAIL e1));
     151      <? &Free-Idx> : s.N,
     152        <Gener-Var-Indices s.N (e.Format) "aux" "block"> :: e.aux s.N,
     153        <Store &Free-Idx s.N>,
     154        e1 (FORMAT (PRAGMA) e.aux)
     155        <Flatten-Result s.tail? (e.Re e.aux) e.rest>;
     156    };
    150157  (CALL t.p t.name e.r) e.rest =
    151     <Flatten-Result () e.r> :: e.assigns (e.r),
     158    <Flatten-Result Not-Tail () e.r> :: e.assigns (e.r),
     159    (CALL t.p t.name e.r) :: t1,
    152160    {
    153       e.assigns : v =
    154         <Format-Exp e.Re> :: e.Fe,
    155         <MSG (e.Fe) (e.Fe)> :: e.Fe,  // hack for avoiding non-hard formats
    156         <? &Free-Idx> : s.N,
    157         <Gener-Var-Indices s.N (e.Fe) "aux" "result"> :: e.aux1 s.N,
     161      e.rest : /*empty*/, s.tail? : Tail =
     162        e.assigns (e.Re t1);
     163      <? &Free-Idx> : s.N,
     164        <Gener-Var-Indices s.N (<Format-Exp t1>) "aux" "call"> :: e.aux1 s.N,
    158165        <Store &Free-Idx s.N>,
    159         (RESULT (PRAGMA) e.Re) (FORMAT (PRAGMA) e.aux1)
    160         e.assigns <Flatten-Result (e.aux1 (CALL t.p t.name e.r)) e.rest>;
    161       <Flatten-Result (e.Re (CALL t.p t.name e.r)) e.rest>;
     166        e.assigns (RESULT (PRAGMA) t1) (FORMAT (PRAGMA) e.aux1)
     167        <Flatten-Result s.tail? (e.Re e.aux1) e.rest>;
    162168    };
    163169  (PAREN e.r) e.rest =
    164     <Flatten-Result () e.r> :: e.assigns (e.r),
    165     e.assigns <Flatten-Result (e.Re (PAREN e.r)) e.rest>;
    166   t1 e.rest = <Flatten-Result (e.Re t1) e.rest>;
     170    <Flatten-Result Not-Tail () e.r> :: e.assigns (e.r),
     171    e.assigns <Flatten-Result s.tail? (e.Re (PAREN e.r)) e.rest>;
     172  t1 e.rest = <Flatten-Result s.tail? (e.Re t1) e.rest>;
    167173  /*empty*/ = (e.Re);
    168174};
  • to-imperative/trunk/compiler/rfp_asail2asail.rf

    r2043 r2068  
    1313$func Remove-Dupl-Decl (e.decls) (e.subst) e.asail = e.asail;
    1414
     15$func Process-Var (e.decls) (e.subst) s.type t.var = e.maybe-decl (e.decls) (e.subst);
     16
    1517$func Free-Idx = s.idx;
    1618
     19$box Idx;
     20
    1721
    1822Simplify-ASAIL e.asail =
     23  <Store &Idx>,
    1924  <Remove-Dupl-Decl () () <Remove-Unreachable <Simplify e.asail>>>;
    2025
     
    125130Remove-Dupl-Decl (e.decls) (e.subst) e.items, e.items : {
    126131  t1 e.rest = {
    127     t1 : (DECL s.type t.var) = {
    128       e.decls : $r e (DECL s.type-old t.var) e = {
    129         s.type : s.type-old = <Remove-Dupl-Decl (e.decls) (e.subst) e.rest>;
    130         t.var : (s.tag e (e.name)),
    131           (s.tag 'dd' (e.name <Free-Idx>)) :: t.new-var,
    132           (DECL s.type t.new-var) :: t.new-decl,
    133           t.new-decl <Remove-Dupl-Decl (e.decls t.new-decl) (e.subst (t.var t.new-var)) e.rest>;
    134       };
    135       t1 <Remove-Dupl-Decl (e.decls t1) (e.subst) e.rest>;
    136     };
    137     t1 : (EXPR t.var e.expr) = {
    138       e.decls : $r e (DECL s.type-old t.var) e = {
    139         s.type-old : Expr =
    140           (ASSIGN t.var <Remove-Dupl-Decl (e.decls) (e.subst) e.expr>)
    141           <Remove-Dupl-Decl (e.decls) (e.subst) e.rest>;
    142         t.var : (s.tag e (e.name)),
    143           (s.tag 'dd' (e.name <Free-Idx>)) :: t.new-var,
     132    t1 : (DECL s.type t.var) =
     133      <Process-Var (e.decls) (e.subst) s.type t.var> :: e.d (e.decls) (e.subst),
     134      e.d <Remove-Dupl-Decl (e.decls) (e.subst) e.rest>;
     135    t1 : (EXPR t.var e.expr) =
     136      <Process-Var (e.decls) (e.subst) Expr t.var> :: e.d (e.decls2) (e.subst2),
     137      {
     138        e.d : (DECL s t.new-var) =
    144139          (EXPR t.new-var <Remove-Dupl-Decl (e.decls) (e.subst) e.expr>)
    145           <Remove-Dupl-Decl (e.decls (DECL Expr t.new-var)) (e.subst (t.var t.new-var)) e.rest>;
    146       };
    147       (EXPR t.var <Remove-Dupl-Decl (e.decls) (e.subst) e.expr>)
    148       <Remove-Dupl-Decl (e.decls (DECL Expr t.var)) (e.subst) e.rest>;
    149     };
     140          <Remove-Dupl-Decl (e.decls2) (e.subst2) e.rest>;
     141        (ASSIGN t.var <Remove-Dupl-Decl (e.decls) (e.subst) e.expr>)
     142        <Remove-Dupl-Decl (e.decls2) (e.subst2) e.rest>;
     143      };
     144    t1 : (s.split expr (e.len) t.var1 t.var2), s.split : \{ LSPLIT; RSPLIT; } =
     145      <Remove-Dupl-Decl (e.decls) (e.subst) expr (e.len)> :: expr,
     146      <Process-Var (e.decls) (e.subst) Split t.var1> :: e.decl1 (e.decls) (e.subst),
     147      {
     148        e.decl1 : (DECL s.type t.new-var) = t.new-var;
     149        t.var1;
     150      } :: t.var1,
     151      <Process-Var (e.decls) (e.subst) Split t.var2> :: e.decl2 (e.decls) (e.subst),
     152      {
     153        e.decl2 : (DECL s.type t.new-var) = t.new-var;
     154        t.var2;
     155      } :: t.var2,
     156      (s.split expr t.var1 t.var2) <Remove-Dupl-Decl (e.decls) (e.subst) e.rest>;
    150157    e.subst : e (t1 t.new-var) e =
    151158      <Remove-Dupl-Decl (e.decls) (e.subst) t.new-var e.rest>;
     
    155162  };
    156163  /*empty*/ = /*empty*/;
     164};
     165
     166Process-Var (e.decls) (e.subst) s.type t.var, {
     167  e.decls : $r e (DECL s.type-old t.var) e = {
     168    s.type : s.type-old = /*empty*/ (e.decls) (e.subst);
     169    t.var : (s.tag e (e.name)),
     170      (s.tag 'dd' (e.name <Free-Idx>)) :: t.new-var,
     171      (DECL s.type t.new-var) :: t.decl,
     172      t.decl (e.decls t.decl) (e.subst (t.var t.new-var));
     173  };
     174  (DECL s.type t.var) (e.decls (DECL s.type t.var)) (e.subst);
    157175};
    158176
     
    220238
    221239
    222 $box Idx;
    223 
    224240Free-Idx =
    225241  {
  • to-imperative/trunk/compiler/rfp_asail_java.rf

    r2043 r2068  
    8484        <? &Entry-Name> : v.name =
    8585          ()
    86           ('public static void main (java.lang.String[] args) {'
    87             (('RefalRuntime.setArgs ("'e.java-module-name'", args);')
    88              ('try {' (v.name' (new Result ());') '}')
    89              ('catch (RefalException e) {' ('System.out.println ("$error: " + e);') '}')
    90             )
    91           '}');;
     86          ('public static void main (java.lang.String[] args) {' (
     87            ('RefalRuntime.setArgs ("'e.java-module-name'", args);')
     88            ('try {' (v.name' (new Result ());') '}')
     89            ('catch (RefalException e) {' (
     90              ('java.lang.System.out.println ("$error: " + e);')
     91              ('java.lang.System.exit (100);')
     92            )'}')
     93          )'}');;
    9294      } :: e.entry,
    9395      (e.java-module-name)
  • to-imperative/trunk/compiler/rfp_check.rf

    r2034 r2068  
    6060 * 4) All function calls are performed with expressions of right formats.
    6161 */
    62 Satisfies-Format? (e.InFormat) (e.OutFormat) e.Sentence =
     62Satisfies-Format? (e.InFormat) (e.OutFormat) e.Sentence, {
     63  e.Sentence : $r e.Snt (ERROR t) e.queue =
     64    <Satisfies-Format? () ((EVAR)) e.queue>,
     65    <Satisfies-Format? (e.InFormat) () e.Snt>;
    6366  e.Sentence (e.OutFormat) $iter {
    64     e.Sentence : $r e.Snt (ERROR t) e.queue =
    65       <Satisfies-Format? () ((EVAR)) e.queue>,
    66       e.Snt ();
    6767    e.Sentence : e.Snt t.Statement,
    6868      t.Statement : {
    6969        (RESULT t.Pragma e.ResultExpression) =
    7070          {
     71            e.ResultExpression : (s.block e), s.block : \{ BLOCK; BLOCK?; } =
     72              <Satisfies-Format? () (e.OutFormat) e.ResultExpression>,
     73              e.Snt ();
    7174            <Subformat? (e.OutFormat) (<Format-Exp e.ResultExpression>)> =
    7275              <Check-Inputs e.ResultExpression>,
     
    131134        (CUT t) = e.Snt ();
    132135        (STAKE t) = e.Snt ();
    133         (BRANCH t e.Snt1) = e.Snt1 (e.OutFormat);
     136        (BRANCH t e.Snt1) =
     137          <Satisfies-Format? (e.InFormat) (e.OutFormat) e.Snt1> ();
    134138        (Comp Branch) = /*empty*/ ();
    135139      };
    136140  } :: e.Sentence (e.OutFormat),
    137141  e.Sentence : /*empty*/;
     142};
    138143
    139144/*
  • to-imperative/trunk/compiler/rfp_clashes.rf

    r1950 r2068  
    213213      (0) (0) e.Pe;
    214214    } : (e.left) (e.right) expr,
    215     <UHP-Clash LEFT  &L- 1 0 () () (e.left ) (t.Re) expr>
     215    <UHP-Clash LEFT  &L 1 0 () () (e.left ) (t.Re) expr>
    216216      :: e.l-clashes (e.l-conds) (e.l-assigns) (e.left ) (expr),
    217     <UHP-Clash RIGHT &R- 0 1 () () (e.right) (t.Re) expr>
     217    <UHP-Clash RIGHT &R 0 1 () () (e.right) (t.Re) expr>
    218218      :: e.r-clashes (e.r-conds) (e.r-assigns) (e.right) (expr),
    219219    <Bind &Hard-Parts (s.idx) ((e.left) (e.right) expr)>,
  • to-imperative/trunk/compiler/rfp_compile.rf

    r2052 r2068  
    9292
    9393$func Prepare-Res e.Reult-exprs = e.Result-exprs;
     94
     95$func Prepare-Const e.const-expr = e.const-expr;
    9496
    9597$func Comp-Assigns e.assignments = e.asail-assignments;
     
    164166        (e.decl) e.comp-func;
    165167      (s.link CONST t.pragma t.name e.expr) =
    166         (CONSTEXPR s.link t.name (e.expr) e.expr) :: t.const,
     168        (CONSTEXPR s.link t.name (e.expr) <Prepare-Const e.expr>) :: t.const,
    167169        <Put &Declarations t.const>,
    168170        {
     
    790792  };
    791793
     794
     795Prepare-Const {
     796  (PAREN expr) e.rest = (PAREN <Prepare-Const expr>) <Prepare-Const e.rest>;
     797  t1 e.rest = <Ref-Func? t1> <Prepare-Const e.rest>;
     798  /*empty*/ = /*empty*/;
     799};
    792800
    793801
  • to-imperative/trunk/compiler/rfp_format.rf

    r2043 r2068  
    1010$func Split-Rt t.Ft t.Rt = e.splited-Rt;
    1111
    12 //$func MSG-Exprs (e.Fe1) e.Fe2 = e.Fe;
    13 $func MSG-Exprs e = e;
     12$func MSG-Exprs (e.Fe1) e.Fe2 = e.Fe;
    1413
    1514$func MSG-Terms t.Ft1 t.Ft2 = t.Ft;
     
    116115 */
    117116MSG-Exprs {
     117  ((FAIL)) e.Fe2 = e.Fe2;
     118  (e.Fe1) (FAIL) = e.Fe1;
    118119  (t.Ft1 e.Fe1) t.Ft2 e.Fe2 \?
    119120    /*
  • to-imperative/trunk/compiler/rfp_helper.rf

    r1950 r2068  
    44
    55$use Access Arithm Box Class Compare StdIO Table;
    6 
    7 Abs s.num, {
    8   <"<" (s.num) (0)> = <"*" s.num -1>;
    9   s.num;
    10 };
    11 
    12 Max s1 s2, {
    13   <">" (s1) (s2)> = s1;
    14   s2;
    15 };
    166
    177$table Empty-Table;
     
    8373
    8474/*
    85  * Repeat e.expr s.num times.
    86  */
    87 Repeat {
    88   0 e = /*empty*/;
    89   s.num expr = expr <Repeat <"-" s.num 1> expr>;
    90 };
    91 
    92 /*
    9375 * Search for e.pattern in expr (in all depths).
    9476 */
     
    9880};
    9981
    100 
    101 L- s1 e2 = <L s1 e2>;
    102 
    103 R- s1 e2 = <R s1 e2>;
    104 
    105 Char?- e1 = <Char? e1>;
    106 
    107 Int?- e1 = <Int? e1>;
    108 
  • to-imperative/trunk/compiler/rfp_helper.rfi

    r1950 r2068  
    55$table RFP-Options ;
    66$table RFP-Module-Subst;
    7 
    8 $func Abs s.num = s.abs;
    9 
    10 //$func Max s1 s2 = s.max;
    11 $func Max e = e;
    127
    138$func RFP-Clear-Table s.tbl = ;
     
    2621$func Subst (e.patterns) (e.replaces) expr = expr;
    2722
    28 // repeat e.expr s.num times
    29 $func Repeat s.num expr = expr;
    30 
    3123// search for e.pattern in expr (in all depths).
    3224$func? In? (e.pattern) expr = ;
    3325
    3426
    35 $func? L- e = e;
    36 
    37 $func? R- e = e;
    38 
    39 $func? Char?- e = e;
    40 
    41 $func? Int?- e = e;
    42 
  • to-imperative/trunk/compiler/rfp_lex.rf

    r2043 r2068  
    100100  e.ts <Scan-Tokens>;
    101101
     102Find-Includes e.filename =
     103  <Store &Source>,
     104  <Store &Saved-Sources>,
     105  <Store &Position>,
     106  <Store &Source-Index>,
     107  <Store &Src-Counter 0>,
     108  {
     109    <RFP-Src-Open-File e.filename>;
     110    <PrintLN! &StdErr 'Error: cannot open source file ' e.filename>,
     111      <Exit 1>;
     112  } :: e.source,
     113  <Push-Source e.source S 0 1>,
     114  (/*e.includes*/) (/*e.line*/) /*e.stop?*/ $iter <Scan-Token e.line> : {
     115    ((e (EOF))) e = (e.includes) () STOP;
     116    ((e (USE))) (e.ln) =
     117      () (e.ln) /*e.st?*/ $iter <Scan-Token e.ln> : {
     118        ((e (SEMICOLON))) (e.l) = (e.incs) (e.l) STOP;
     119        (((e.p) (s.WORD-or-QWORD e.s))) (e.l),
     120          s.WORD-or-QWORD : \{
     121            WORD;
     122            QWORD;
     123          } =   (e.incs (e.s)) (e.l);
     124        (((e.p) (EOF))) =
     125          <PrintLN! &StdErr 'Error: unexpected end of file during $use parsing'>,
     126          <Exit 2>, () ();
     127        (((e.p) (e.tag))) =
     128          <PrintLN! &StdErr 'Error: unexpected token 'e.tag' during $use parsing'>,
     129          <Exit 2>, () ();
     130      } :: (e.incs) (e.ln) e.st?,
     131      e.st? : STOP =
     132      (e.includes e.incs) (e.ln);
     133    e (e.ln) = (e.includes) (e.ln);
     134  } :: (e.includes) (e.line) e.stop?,
     135  e.stop? : STOP =
     136  e.includes;
     137
    102138Push-Source e.source s.type s.row s.col =
    103139  <? &Src-Counter> : s.n,
     
    134170        e.t : {
    135171          ((e) (SEMICOLON)) = (e.nts) (e.line) F;
    136           ((e.p) (s.WORD-or-QWORD e.s)) =
     172          ((e.p) (s.WORD-or-QWORD e.s)),
     173            s.WORD-or-QWORD : \{
     174              WORD = CI;
     175              QWORD = NOT-CI;
     176            } :: s.ci? =
    137177            {
    138178              <Lookup &RFP-Module-Subst e.s>;
    139179              e.s;
    140180            } :: e.s,
    141             {
    142               s.WORD-or-QWORD : WORD = CI;
    143               NOT-CI;
    144             } :: s.ci?,
    145181            {
    146182              <RFP-Debug?>, <PrintLN "Processing " e.s>;;
     
    153189                e.nts;
    154190            } :: e.nts,
     191            (e.nts) (e.line) T;
     192          ((e.p) (EOF)) =
     193            <RFP-Error (e.p) ("Unexpected end of file")>,
     194            (e.nts) (e.line) F;
     195          ((e.p) (e.tag)) =
     196            <RFP-Error (e.p) ("Unexpected token "e.tag)>,
    155197            (e.nts) (e.line) T;
    156198        };
  • to-imperative/trunk/compiler/rfp_lex.rfi

    r683 r2068  
    2222
    2323$func RFP-Lexer e.filename = e.tokens ;
     24
     25$func Find-Includes e.filename = e.includes ;
  • to-imperative/trunk/compiler/rfp_parse.rf

    r2042 r2068  
    560560    (e.pos) /*empty*/ $iter
    561561      {
    562         e.items (BRANCH <Pragma e.snt-end-pos> <Parse-Sentence e.colon-pos>)
     562        e.items (BRANCH <Pragma e.snt-end-pos> <Parse-Alt e.colon-pos>)
    563563        :: e.items,
    564564          <Expect-Token SEMICOLON> :: (e.snt-end-pos) t,
     
    645645Parse-Source // [] = e.item
    646646  =
    647   <Expect-Token LBRACE TLBRACE EMPTY> :: (e.pos) (s.type e),
     647//  <Expect-Token LBRACE TLBRACE EMPTY> :: (e.pos) (s.type e),
    648648  {
    649     s.type :
    650       \{
    651         LBRACE;
    652         TLBRACE;
    653       } =
    654         (e.pos) /*empty*/ $iter
    655           {
    656             e.items (BRANCH <Pragma e.snt-end-pos> <Parse-Path>) :: e.items,
    657               <Expect-Token SEMICOLON> :: (e.snt-end-pos) t,
    658               (e.snt-end-pos) e.items;
    659           } :: (e.snt-end-pos) e.items,
    660             <Expect-Token RBRACE EMPTY> : (e) (RBRACE e),
    661             {
    662               s.type : LBRACE = (BLOCK <Pragma e.pos> e.items);
    663               (BLOCK? <Pragma e.pos> e.items);
    664             };
    665     (RESULT <Pragma e.pos> <Parse-Result>);
     649//    s.type :
     650//      \{
     651//        LBRACE;
     652//        TLBRACE;
     653//      } =
     654//        (e.pos) /*empty*/ $iter
     655//          {
     656//            e.items (BRANCH <Pragma e.snt-end-pos> <Parse-Path>) :: e.items,
     657//              <Expect-Token SEMICOLON> :: (e.snt-end-pos) t,
     658//              (e.snt-end-pos) e.items;
     659//          } :: (e.snt-end-pos) e.items,
     660//            <Expect-Token RBRACE EMPTY> : (e) (RBRACE e),
     661//            {
     662//              s.type : LBRACE = (BLOCK <Pragma e.pos> e.items);
     663//              (BLOCK? <Pragma e.pos> e.items);
     664//            };
     665    <Expect-Token EMPTY> :: (e.pos) e,
     666      (RESULT <Pragma e.pos> <Parse-Result>);
    666667  } :: e.items,
    667668  e.items <Expect-Token COLON EMPTY> $iter {
     
    734735        <Expect-Token RBRACKET> : e, e.items;
    735736      s.type : \{ LBRACE; TLBRACE; } =
    736         <Unget-Token (e.pos) (s.type e.value)>,
    737         <Parse-Source>;
     737        (e.pos) /*empty*/ $iter {
     738          e.items (BRANCH <Pragma e.snt-end-pos> <Parse-Path>) :: e.items,
     739            <Expect-Token SEMICOLON> :: (e.snt-end-pos) t,
     740            (e.snt-end-pos) e.items;
     741        } :: (e.snt-end-pos) e.items,
     742        <Expect-Token RBRACE EMPTY> : (e) (RBRACE e),
     743        {
     744          s.type : LBRACE = (BLOCK <Pragma e.pos> e.items);
     745          (BLOCK? <Pragma e.pos> e.items);
     746        };
    738747    };
    739748
  • to-imperative/trunk/compiler/rfpc.rf

    r2043 r2068  
    3636$use "rfp_asail2asail";
    3737
    38 $use StdIO;
    39 $use Box;
    40 $use Dos;
    41 $use Arithm;
    42 $use Table;
    43 $use Convert;
    44 $use Class;
    45 $use Access;
    46 $use Compare;
    47 $use CppMangle;
     38$use Access Arithm Box Class Compare Convert CppMangle Dos List Table StdIO;
    4839
    4940$const RevDate = ('$Revision$') ('$Date$');
     
    110101                  <Store s.len <"+" s.st-len s.n-len>>,
    111102                  <PrintLN>,
    112                   <Print <Repeat s.st-len ' '>>;
     103                  <Print <Replicate s.st-len ' '>>;
    113104                <Store s.len s.new>;
    114105              },
     
    360351              <Open-Channel e.java-module-name ('.java')> :: s.channel s.need-close?,
    361352              {
    362                 e.dirname : v =
    363                   <PrintLN! s.channel
    364                   'package '<Subst (&RFP-Dir-Separator) (('.')) e.dirname>';\n'>;;
     353                <? &RFP-Include-Path> : e (e.dir) e,
     354                  e.dirname : \{
     355                    e.dir = /*empty*/;
     356                    e.dir &RFP-Dir-Separator e.package = e.package;
     357                  };
     358                e.dirname;
     359              } :: e.package,
     360              {
     361                e.package : v =
     362                  <PrintLN! s.channel 'package 'e.package';\n'>;;
    365363              },
    366364              <PrintLN! s.channel 'import org.refal.plus.*;'>,
     
    440438  ' ' :: e.start1,
    441439  29 :: s.2nd-col,
    442   <Repeat s.2nd-col ' '> :: e.start2,
     440  <Replicate s.2nd-col ' '> :: e.start2,
    443441  <PrintLN "Refal+ compiler " <Version>>,
    444442  <PrintLN "Copyright blah-blah-blah">,
     
    467465          <PrintLN
    468466            <? s.line>
    469             <Repeat <"-" s.2nd-col <Length <? s.line>>> ' '>
     467            <Replicate <"-" s.2nd-col <Length <? s.line>>> ' '>
    470468            s.phrase
    471469          >,
Note: See TracChangeset for help on using the changeset viewer.