Changeset 3659


Ignore:
Timestamp:
Mar 31, 2008, 7:31:21 PM (13 years ago)
Author:
yura
Message:
  • StdIO java+refal;
Location:
to-imperative/trunk/java
Files:
3 added
2 deleted
1 moved

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/java/java/refal/plus/StdIO.java

    r3658 r3659  
    1515import org.refal.plus.Channel;
    1616import org.refal.plus.Expr;
    17 import org.refal.plus.Func;
    1817import org.refal.plus.RefalException;
    1918import org.refal.plus.RefalFormat;
    2019import org.refal.plus.Result;
    21 import org.refal.plus.Symbol;
    22 
    2320
    2421public class StdIO {
     
    190187    // ///////////////////// Begining of generated part ///////////////////
    191188
    192   @RefalFormat("$const ReadChunkSize = 64;")
    193   static public final Expr ReadChunkSize = new Expr (Symbol.newInt ("64"));
    194   @RefalFormat("$table Buffers;")
    195   static  final Expr Buffers = new Expr (Symbol.newTable ("Buffers"));
    196   static  final Expr _c_0 = Expr.concat (Symbol.newWord ("StdIO"), Symbol.newWord ("OpenFile"));
    197   static  final Expr _c_1 = new Expr (Symbol.newWord ("Arg 1 is not a Channel"));
    198   static  final Expr _c_2 = new Expr (Symbol.newWord ("Arg 3 is not a Word"));
    199   static  final Expr _c_3 = new Expr (new Func () {
    200     public boolean eval (Expr arg, Result res) throws RefalException {
    201       return PrimRead_0 (arg, res);
    202     }
    203   });
    204   static  final Expr _c_4 = Expr.concat (Symbol.newWord ("StdIO"), Symbol.newWord ("CloseChannel"));
    205   static  final Expr _c_5 = Expr.concat (Symbol.newWord ("StdIO"), Symbol.newWord ("IsEof"));
    206   static  final Expr _c_6 = new Expr (Symbol.newWord ("Channel is not open"));
    207   static  final Expr _c_7 = Expr.concat (Symbol.newWord ("StdIO"), Symbol.newWord ("ReadCharCh"));
    208   static  final Expr _c_8 = Expr.fromSequence ("\r\n");
    209   static  final Expr _c_9 = _c_8.subexpr (1, 1);
    210   static  final Expr _c_10 = _c_8.subexpr (0, 1);
    211   static  final Expr _c_11 = Expr.concat (Symbol.newWord ("StdIO"), Symbol.newWord ("ReadLineCh"));
    212   static  final Expr _c_12 = new Expr (Symbol.newWord ("ReadCh"));
    213   static  final Expr _c_13 = new Expr (Symbol.newWord ("Read"));
    214   static  final Expr _c_14 = _c_5.subexpr (0, 1);
    215   static  final Expr _c_15 = Expr.getConcatenator (3).toRight (Symbol.newWord ("Apply")).toRight (Symbol.newWord ("Apply")).toRight (Symbol.newWord ("Unexpected fail")).yield ();
    216 
    217   @RefalFormat("$func? OpenFile s e s = ;")
    218   static public boolean OpenFile (Expr _vs_channel, Expr _ve_file, Expr _vs_mode) throws RefalException
    219   {
    220     _block1: {
    221       _block1__branch1: {
    222         _negation1: {
    223           if (!refal.plus.Class.IsChannel (_vs_channel))
    224           {
    225             break _negation1;
    226           }
    227           break _block1__branch1;
    228         }
    229          refal.plus.Error.Lib_Error (_c_0, _c_1);
    230         break _block1;
    231       }
    232       _block1__branch2: {
    233         _negation2: {
    234           if (!refal.plus.Class.IsWord (_vs_mode))
    235           {
    236             break _negation2;
    237           }
    238           break _block1__branch2;
    239         }
    240         refal.plus.Error.Lib_Error (_c_0, _c_2);
    241         break _block1;
    242       }
    243       if (!PrimOpenFile (_vs_channel, _ve_file, _vs_mode))
    244       {
    245         return false;
    246       }
    247       Result _gs_auxcall1 = new Result ();
    248       refal.plus.Stream.Stream (_c_3, Expr.concat (_vs_channel, ReadChunkSize), _gs_auxcall1);
    249       refal.plus.Table.Bind (Buffers, _vs_channel, _gs_auxcall1.getExpr ());
    250     }
    251     return true;
    252   }
    253 
    254   @RefalFormat("$func CloseChannel s = ;")
    255   static public void CloseChannel (Expr _vs_channel) throws RefalException
    256   {
    257     _block1: {
    258       _block1__branch1: {
    259         _negation1: {
    260           if (!refal.plus.Class.IsChannel (_vs_channel))
    261           {
    262             break _negation1;
    263           }
    264           break _block1__branch1;
    265         }
    266         refal.plus.Error.Lib_Error (_c_4, _c_1);
    267         break _block1;
    268       }
    269       PrimCloseChannel (_vs_channel);
    270       refal.plus.Table.Unbind (Buffers, _vs_channel);
    271     }
    272   }
    273 
    274   @RefalFormat("$func? IsEof s = ;")
    275   static public boolean IsEof (Expr _vs_channel) throws RefalException
    276   {
    277     _block1: {
    278       _block1__branch1: {
    279         Result _v_Lookup1 = new Result ();
    280         if (!refal.plus.Table.Lookup (Buffers, _vs_channel, _v_Lookup1))
    281         {
    282           break _block1__branch1;
    283         }
    284         if (_v_Lookup1.getExpr ().length () != 1)
    285         {
    286           break _block1__branch1;
    287         }
    288         if (!_v_Lookup1.getExpr ().isSymbolAt (0))
    289         {
    290           break _block1__branch1;
    291         }
    292         Expr _vs_tream = Expr.empty;
    293         _vs_tream = _v_Lookup1.getExpr ().subexpr (0, 1);
    294         if (!refal.plus.Stream.IsEnd_of_Stream (_vs_tream)) {
    295           return false;
    296         }
    297         break _block1;
    298       }
    299       refal.plus.Error.Lib_Error (_c_5, _c_6);
    300     }
    301     return true;
    302   }
    303 
    304   @RefalFormat("$func? ReadCharCh s = s;")
    305   static public boolean ReadCharCh (Expr _vs_channel, Result _v_res1) throws RefalException
    306   {
    307     _block1: {
    308       _block1__branch1: {
    309         Result _v_Lookup1 = new Result ();
    310         if (!refal.plus.Table.Lookup (Buffers, _vs_channel, _v_Lookup1))
    311         {
    312           break _block1__branch1;
    313         }
    314         if (_v_Lookup1.getExpr ().length () != 1)
    315         {
    316           break _block1__branch1;
    317         }
    318         if (!_v_Lookup1.getExpr ().isSymbolAt (0))
    319         {
    320           break _block1__branch1;
    321         }
    322         Expr _vs_tream = Expr.empty;
    323         _vs_tream = _v_Lookup1.getExpr ().subexpr (0, 1);
    324         Result _v_Getc1 = new Result ();
    325         if (!refal.plus.Stream.Getc (_vs_tream, _v_Getc1))
    326         {
    327           return false;
    328         }
    329         if (!_v_Getc1.getExpr ().isSymbolAt (0))
    330         {
    331           return false;
    332         }
    333         Expr _vs_char = Expr.empty;
    334         _vs_char = _v_Getc1.getExpr ().subexpr (0, 1);
    335         _v_res1.assign (_vs_char);
    336         break _block1;
    337       }
    338       refal.plus.Error.Lib_Error (_c_7, _c_6);
    339       return false;
    340     }
    341     return true;
    342   }
    343 
    344   @RefalFormat("$func? ReadChar = s;")
    345   static public boolean ReadChar (Result _v_res1) throws RefalException
    346   {
    347     if (!ReadCharCh (StdIn, _v_res1)) {
    348       return false;
    349     }
    350     return true;
    351   }
    352 
    353   @RefalFormat("$func? ReadLineCh s = e;")
    354   static public boolean ReadLineCh (Expr _vs_channel, Result _v_res1) throws RefalException
    355   {
    356     _block1: {
    357       _block1__branch1: {
    358         Result _v_Lookup1 = new Result ();
    359         if (!refal.plus.Table.Lookup (Buffers, _vs_channel, _v_Lookup1))
    360         {
    361           break _block1__branch1;
    362         }
    363         if (_v_Lookup1.getExpr ().length () != 1)
    364         {
    365           break _block1__branch1;
    366         }
    367         if (!_v_Lookup1.getExpr ().isSymbolAt (0))
    368         {
    369           break _block1__branch1;
    370         }
    371         Expr _vs_tream = Expr.empty;
    372         _vs_tream = _v_Lookup1.getExpr ().subexpr (0, 1);
    373         Result _v_Get__Line1 = new Result ();
    374         refal.plus.Stream.Get_Line (_vs_tream, _v_Get__Line1);
    375         _block2: {
    376           _block2__branch1: {
    377             int _v_len1;
    378             _v_len1 = _v_Get__Line1.getExpr ().length ();
    379             int _v_len2;
    380             _v_len2 = 2;
    381             if (_v_len1 < _v_len2)
    382             {
    383               break _block2__branch1;
    384             }
    385             int _v_len__line;
    386             _v_len__line = (_v_len1 - _v_len2);
    387             if (!_c_8.equals (_v_Get__Line1.getExpr (), (0 + _v_len__line)))
    388             {
    389               break _block2__branch1;
    390             }
    391             Expr _ve_line = Expr.empty;
    392             _ve_line = _v_Get__Line1.getExpr ().subexpr (0, _v_len__line);
    393             _v_res1.assign (_ve_line);
    394             break _block2;
    395           }
    396           _block2__branch2: {
    397             int _v_len3;
    398             _v_len3 = _v_Get__Line1.getExpr ().length ();
    399             int _v_len4;
    400             _v_len4 = 1;
    401             if (_v_len3 < _v_len4)
    402             {
    403               break _block2__branch2;
    404             }
    405             int _v_len__line2;
    406             _v_len__line2 = (_v_len3 - _v_len4);
    407             if (!_c_9.termEquals (_v_Get__Line1.getExpr (), (0 + _v_len__line2)))
    408             {
    409               break _block2__branch2;
    410             }
    411             Expr _ve_line = Expr.empty;
    412             _ve_line = _v_Get__Line1.getExpr ().subexpr (0, _v_len__line2);
    413             _v_res1.assign (_ve_line);
    414             break _block2;
    415           }
    416           _block2__branch3: {
    417             int _v_len5;
    418             _v_len5 = _v_Get__Line1.getExpr ().length ();
    419             int _v_len6;
    420             _v_len6 = 1;
    421             if (_v_len5 < _v_len6)
    422             {
    423               break _block2__branch3;
    424             }
    425             int _v_len__line3;
    426             _v_len__line3 = (_v_len5 - _v_len6);
    427             if (!_c_10.termEquals (_v_Get__Line1.getExpr (), (0 + _v_len__line3)))
    428             {
    429               break _block2__branch3;
    430             }
    431             Expr _ve_line = Expr.empty;
    432             _ve_line = _v_Get__Line1.getExpr ().subexpr (0, _v_len__line3);
    433             _v_res1.assign (_ve_line);
    434             break _block2;
    435           }
    436           int _v_len7;
    437           _v_len7 = _v_Get__Line1.getExpr ().length ();
    438           int _v_len8;
    439           _v_len8 = 0;
    440           if (_v_len7 < (_v_len8 + 1))
    441           {
    442             return false;
    443           }
    444           int _v_len__line4;
    445           _v_len__line4 = (_v_len7 - _v_len8);
    446           Expr _vv_line = Expr.empty;
    447           _vv_line = _v_Get__Line1.getExpr ().subexpr (0, _v_len__line4);
    448           _v_res1.assign (_vv_line);
    449         }
    450         break _block1;
    451       }
    452       refal.plus.Error.Lib_Error (_c_11, _c_6);
    453       return false;
    454     }
    455     return true;
    456   }
    457 
    458   @RefalFormat("$func? ReadLine = e;")
    459   static public boolean ReadLine (Result _v_res1) throws RefalException
    460   {
    461     if (!ReadLineCh (StdIn, _v_res1)) {
    462       return false;
    463     }
    464     return true;
    465   }
    466 
    467   @RefalFormat("$func? ReadCh s = t;")
    468   static public boolean ReadCh (Expr _vs_channel, Result _v_res1) throws RefalException
    469   {
    470     if (!Read_Main (_c_12, _vs_channel, _v_res1)) {
    471       return false;
    472     }
    473     return true;
    474   }
    475 
    476   @RefalFormat("$func? Read = t;")
    477   static public boolean Read (Result _v_res1) throws RefalException
    478   {
    479     if (!Read_Main (_c_13, StdIn, _v_res1)) {
    480       return false;
    481     }
    482     return true;
    483   }
    484 
    485   @RefalFormat("$func? Read_Main s s = t;")
    486   static  boolean Read_Main (Expr _vs_fname, Expr _vs_channel, Result _v_res1) throws RefalException
    487   {
    488     _block1: {
    489       _block1__branch1: {
    490         Result _v_Lookup1 = new Result ();
    491         if (!refal.plus.Table.Lookup (Buffers, _vs_channel, _v_Lookup1))
    492         {
    493           break _block1__branch1;
    494         }
    495         if (_v_Lookup1.getExpr ().length () != 1)
    496         {
    497           break _block1__branch1;
    498         }
    499         if (!_v_Lookup1.getExpr ().isSymbolAt (0))
    500         {
    501           break _block1__branch1;
    502         }
    503         Expr _vs_tream = Expr.empty;
    504         _vs_tream = _v_Lookup1.getExpr ().subexpr (0, 1);
    505         Expr _ve_result = Expr.empty;
    506         _block2: {
    507           _block2__branch1: {
    508             Result _va_1 = new Result ();
    509             if (!refal.plus.Lexer.IsRead_Term (_vs_tream, _va_1))
    510             {
    511               break _block2__branch1;
    512             }
    513             _ve_result = _va_1.getExpr ();
    514             break _block2;
    515           }
    516           _ve_result = Expr.empty;
    517         }
    518         _block3__branch1: {
    519           Result _v_Errors1 = new Result ();
    520           refal.plus.StreamErr.Errors (_v_Errors1);
    521           int _v_len1;
    522           _v_len1 = _v_Errors1.getExpr ().length ();
    523           int _v_len2;
    524           _v_len2 = 1;
    525           if (_v_len1 < _v_len2)
    526           {
    527             break _block3__branch1;
    528           }
    529           int _v_len___dollar_tmp_m_86_m_46;
    530           _v_len___dollar_tmp_m_86_m_46 = (_v_len1 - _v_len2);
    531           if (_v_Errors1.getExpr ().isSymbolAt (0))
    532           {
    533             break _block3__branch1;
    534           }
    535           Expr _v_deref__Errors1 = Expr.empty;
    536           _v_deref__Errors1 = (Expr) _v_Errors1.getExpr ().at (0);
    537           if (_v_deref__Errors1.length () != 3)
    538           {
    539             break _block3__branch1;
    540           }
    541           if (_v_deref__Errors1.isSymbolAt ((0 + 1 + 1)))
    542           {
    543             break _block3__branch1;
    544           }
    545           Expr _v_deref__deref__Errors1 = Expr.empty;
    546           _v_deref__deref__Errors1 = (Expr) _v_deref__Errors1.at ((0 + 1 + 1));
    547           int _v_len3;
    548           _v_len3 = _v_deref__deref__Errors1.length ();
    549           int _v_len4;
    550           _v_len4 = 0;
    551           if (_v_len3 < _v_len4)
    552           {
    553             break _block3__branch1;
    554           }
    555           int _v_len__message;
    556           _v_len__message = (_v_len3 - _v_len4);
    557           Expr _ve__dollar_tmp_m_86_m_46 = Expr.empty;
    558           _ve__dollar_tmp_m_86_m_46 = _v_Errors1.getExpr ().subexpr ((0 + 1), _v_len___dollar_tmp_m_86_m_46);
    559           Expr _vt_name = Expr.empty;
    560           _vt_name = _v_deref__Errors1.subexpr (0, 1);
    561           Expr _vt_pos = Expr.empty;
    562           _vt_pos = _v_deref__Errors1.subexpr ((0 + 1), 1);
    563           Expr _ve_message = Expr.empty;
    564           _ve_message = _v_deref__deref__Errors1.subexpr (0, _v_len__message);
    565           refal.plus.Error.Lib_Error (Expr.concat (_c_14, _vs_fname), _ve_message);
    566           return false;
    567         }
    568         if (_ve_result.length () != 1)
    569         {
    570           return false;
    571         }
    572         Expr _vt_erm = Expr.empty;
    573         _vt_erm = _ve_result.subexpr (0, 1);
    574         _v_res1.assign (_vt_erm);
    575         break _block1;
    576       }
    577       refal.plus.Error.Lib_Error (Expr.concat (_c_14, _vs_fname), _c_6);
    578       return false;
    579     }
    580     return true;
    581   }
    582 
    583   static  boolean PrimRead_0 (Expr _ge_arg1, Result _v_res1) throws RefalException
    584   {
    585     if (_ge_arg1.length () != 2)
    586     {
    587       throw new RefalException (_c_15);
    588     }
    589     if (!_ge_arg1.isSymbolAt (0))
    590     {
    591       throw new RefalException (_c_15);
    592     }
    593     if (!_ge_arg1.isSymbolAt ((0 + 1)))
    594     {
    595       throw new RefalException (_c_15);
    596     }
    597     Expr _v_stub1 = Expr.empty;
    598     _v_stub1 = _ge_arg1.subexpr (0, 1);
    599     Expr _v_stub2 = Expr.empty;
    600     _v_stub2 = _ge_arg1.subexpr ((0 + 1), 1);
    601     if (!PrimRead (_v_stub1, _v_stub2, _v_res1)) {
    602       return false;
    603     }
    604     return true;
    605   }
    606 
    607     /////////////////////// End of generated part ///////////////////
    608  
     189    @RefalFormat("$const ReadChunkSize = 64;")
     190    public static final Expr ReadChunkSize = refal.plus.internal.StdIO.ReadChunkSize;
     191
     192    @RefalFormat("$table Buffers;")
     193    static final Expr Buffers = refal.plus.internal.StdIO.Buffers;
     194
     195    @RefalFormat("$func? OpenFile s e s = ;")
     196    public static boolean OpenFile (Expr _vs_channel, Expr _ve_file, Expr _vs_mode) throws RefalException {
     197        return refal.plus.internal.StdIO.OpenFile(_vs_channel, _ve_file, _vs_mode);
     198    }
     199
     200    @RefalFormat("$func CloseChannel s = ;")
     201    public static void CloseChannel (Expr _vs_channel) throws RefalException {
     202        refal.plus.internal.StdIO.CloseChannel(_vs_channel);
     203    }
     204
     205    @RefalFormat("$func? IsEof s = ;")
     206    public static boolean IsEof (Expr _vs_channel) throws RefalException {
     207        return refal.plus.internal.StdIO.IsEof(_vs_channel);
     208    }
     209
     210    @RefalFormat("$func? ReadCharCh s = s;")
     211    public static boolean ReadCharCh (Expr _vs_channel, Result _v_res1) throws RefalException {
     212        return refal.plus.internal.StdIO.ReadCharCh(_vs_channel, _v_res1);
     213    }
     214
     215    @RefalFormat("$func? ReadChar = s;")
     216    public static boolean ReadChar (Result _v_res1) throws RefalException {
     217        return refal.plus.internal.StdIO.ReadChar(_v_res1);
     218    }
     219
     220    @RefalFormat("$func? ReadLineCh s = e;")
     221    public static boolean ReadLineCh (Expr _vs_channel, Result _v_res1) throws RefalException {
     222        return refal.plus.internal.StdIO.ReadLineCh(_vs_channel, _v_res1);
     223    }
     224
     225    @RefalFormat("$func? ReadLine = e;")
     226    public static boolean ReadLine (Result _v_res1) throws RefalException {
     227        return refal.plus.internal.StdIO.ReadLine(_v_res1);
     228    }
     229
     230    @RefalFormat("$func? ReadCh s = t;")
     231    public static boolean ReadCh (Expr _vs_channel, Result _v_res1) throws RefalException {
     232        return refal.plus.internal.StdIO.ReadCh(_vs_channel, _v_res1);
     233    }
     234
     235    @RefalFormat("$func? Read = t;")
     236    public static boolean Read (Result _v_res1) throws RefalException {
     237        return refal.plus.internal.StdIO.Read(_v_res1);
     238    }
     239
     240    // ///////////////////// End of generated part ///////////////////
     241
    609242    static {
    610243        try {
    611             Result _v_Stream1 = new Result();
    612             Stream.Stream(_c_3, Expr.concat(StdIn, BigInteger.ONE), _v_Stream1);
    613             Table.Bind(Buffers, StdIn, _v_Stream1.getExpr());
     244            refal.plus.internal.StdIO.StaticInit();
    614245        } catch (RefalException _) {}
    615246    }
Note: See TracChangeset for help on using the changeset viewer.