Changeset 3707


Ignore:
Timestamp:
Apr 16, 2008, 6:08:36 PM (13 years ago)
Author:
yura
Message:
  • Some functions for Refal Number is Symbol.
Files:
7 edited

Legend:

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

    r3705 r3707  
    1818    public static final Comparable<?> null_object = new Reference<Object>(null);
    1919
     20    public static Comparable<?> newInt (long i) {
     21        return BigInteger.valueOf(i);
     22    }
     23
    2024    public static Comparable<?> newInt (String str) {
    2125        return new BigInteger(str);
     
    2529        return str;
    2630    }
    27 
    2831
    2932    public static Comparable<?> newBox (String name) {
     
    4750    }
    4851
    49 
    5052    public static Reference<StringBuffer> newString () {
    5153        return new Reference<StringBuffer>(new StringBuffer());
     
    5557        return new Reference<Box>(new Box(term));
    5658    }
    57    
     59
    5860    public static Comparable<?> newChannel (String name, InputStream is) {
    5961        return new Reference<Channel>(name, new Channel(is));
     
    6365        return new Reference<Channel>(name, new Channel(os));
    6466    }
    65 
    6667
    6768    public static Box getBox (Expr expr) throws ClassCastException {
     
    8889        res.assign(new Reference<T>(object));
    8990    }
     91
     92    public static BigInteger getBigInteger (Expr expr) throws ClassCastException {
     93        assert expr.length() == 1;
     94        return (BigInteger) expr.at(0);
     95    }
     96
     97    public static int intValue (Expr expr) throws ClassCastException, Util.ValueOutOfBoundsException {
     98        assert expr.length() == 1;
     99        return Util.intValue((BigInteger) expr.at(0));
     100    }
     101
     102    public static int uintValue (Expr expr) throws ClassCastException, Util.NegativeValueException,
     103            Util.ValueOutOfBoundsException {
     104        assert expr.length() == 1;
     105        return Util.uintValue((BigInteger) expr.at(0));
     106    }
     107
     108    public static long ulongValue (Expr expr) throws ClassCastException, Util.NegativeValueException,
     109            Util.ValueOutOfBoundsException {
     110        assert expr.length() == 1;
     111        return Util.ulongValue((BigInteger) expr.at(0));
     112    }
     113
    90114}
  • to-imperative/trunk/java/java/org/refal/plus/Util.java

    r3691 r3707  
    3434    }
    3535
    36     public static int uintValue (Expr expr) throws ClassCastException, NegativeValueException,
    37             ValueOutOfBoundsException {
    38         assert expr.length() == 1;
    39         return uintValue((BigInteger) expr.at(0));
    40     }
    41    
    42     public static BigInteger bigIntegerValue (int i) {
    43         return BigInteger.valueOf(i);
    44     }
    45 
    4636    private static final BigInteger minLong = BigInteger.valueOf(Long.MIN_VALUE);
    4737    private static final BigInteger maxLong = BigInteger.valueOf(Long.MAX_VALUE);
  • to-imperative/trunk/java/java/refal/plus/Access.java

    r3423 r3707  
    1 /*
    2  * $Id$
    3  *
    4  * vim: set syntax=java expandtab shiftwidth=4 tabstop=4:
    5  */
     1// $Id$
    62
    73package refal.plus;
    8 
    9 import java.math.BigInteger;
    104
    115import org.refal.plus.Expr;
     
    137import org.refal.plus.RefalFormat;
    148import org.refal.plus.Result;
     9import org.refal.plus.Symbol;
    1510import org.refal.plus.Util;
    1611
     
    1914    private Access () {}
    2015
    21     @RefalFormat("$func? L s e = t;")
    22     public static boolean L (Expr s_left, Expr e_exp, Result t_subexp) throws RefalException {
    23         assert s_left.length() == 1;
     16    @RefalFormat("$func? L s.left e.expr = t.subTerm;")
     17    public static boolean L (Expr left, Expr expr, Result subTerm) throws RefalException {
    2418        try {
    25             int left = Util.uintValue((BigInteger) s_left.at(0));
    26             if (e_exp.length() == 0 || left > e_exp.length() - 1)
     19            int l = Symbol.uintValue(left);
     20            if (expr.length() <= l)
    2721                return false;
    28             t_subexp.assign(e_exp.subexpr(left, 1));
     22            subTerm.assign(expr.subexpr(l, 1));
    2923            return true;
    30         } catch (Exception e) {
     24        } catch (Util.ValueOutOfBoundsException e) {
     25            throw new RefalException("Access", "L", "Invalid argument");
     26        } catch (ClassCastException e) {
    3127            throw new RefalException("Access", "L", "Invalid argument");
    3228        }
    3329    }
    3430
    35     @RefalFormat("$func? R s.Right e.Exp = t.SubTerm;")
    36     public static boolean R (Expr s_right, Expr e_exp, Result t_subexp) throws RefalException {
    37         assert s_right.length() == 1;
     31    @RefalFormat("$func? R s.right e.expr = t.subTerm;")
     32    public static boolean R (Expr right, Expr expr, Result subTerm) throws RefalException {
    3833        try {
    39             int right = Util.uintValue((BigInteger) s_right.at(0));
    40             if (e_exp.length() == 0 || right > e_exp.length() - 1)
     34            int r = expr.length() - Symbol.uintValue(right);
     35            if (r <= 0)
    4136                return false;
    42             t_subexp.assign(e_exp.subexpr(e_exp.length() - right - 1, 1));
     37            subTerm.assign(expr.subexpr(r - 1, 1));
    4338            return true;
    44         } catch (Exception e) {
     39        } catch (Util.ValueOutOfBoundsException e) {
     40            throw new RefalException("Access", "R", "Invalid argument");
     41        } catch (ClassCastException e) {
    4542            throw new RefalException("Access", "R", "Invalid argument");
    4643        }
    4744    }
    4845
    49     @RefalFormat("$func? Left s.Left s.Len e.Exp = e.SubExp;")
    50     public static boolean Left (Expr s_left, Expr s_len, Expr e_exp, Result e_subexp) throws RefalException {
    51         assert s_left.length() == 1;
    52         assert s_len.length() == 1;
     46    @RefalFormat("$func? Left s.left s.length e.expr = e.subExpr;")
     47    public static boolean Left (Expr left, Expr length, Expr expr, Result subExpr) throws RefalException {
    5348        try {
    54             int len = Util.uintValue((BigInteger) s_len.at(0));
    55             int left = Util.uintValue((BigInteger) s_left.at(0));
    56             if (e_exp.length() < len || left > e_exp.length() - len)
     49            int l = Symbol.uintValue(left);
     50            int len = Symbol.uintValue(length);
     51            if (expr.length() - len < l)
    5752                return false;
    58             e_subexp.assign(e_exp.subexpr(left, len));
     53            subExpr.assign(expr.subexpr(l, len));
    5954            return true;
    60         } catch (Exception e) {
     55        } catch (Util.ValueOutOfBoundsException e) {
     56            throw new RefalException("Access", "Left", "Invalid argument");
     57        } catch (ClassCastException e) {
    6158            throw new RefalException("Access", "Left", "Invalid argument");
    6259        }
    6360    }
    6461
    65     @RefalFormat("$func? Right s.Right s.Len e.Exp = e.SubExp;")
    66     public static boolean Right (Expr s_right, Expr s_len, Expr e_exp, Result e_subexp) throws RefalException {
    67         assert s_right.length() == 1;
    68         assert s_len.length() == 1;
     62    @RefalFormat("$func? Right s.right s.length e.expr = e.subExpr;")
     63    public static boolean Right (Expr right, Expr length, Expr expr, Result subExpr) throws RefalException {
    6964        try {
    70             int len = Util.uintValue((BigInteger) s_len.at(0));
    71             int right = Util.uintValue((BigInteger) s_right.at(0));
    72             if (e_exp.length() < len || right > e_exp.length() - len)
     65            int r = expr.length() - Symbol.uintValue(right);
     66            int len = Symbol.uintValue(length);
     67            if (r < len)
    7368                return false;
    74             e_subexp.assign(e_exp.subexpr(e_exp.length() - right - len, len));
     69            subExpr.assign(expr.subexpr(r - len, len));
    7570            return true;
    76         } catch (Exception e) {
     71        } catch (Util.ValueOutOfBoundsException e) {
     72            throw new RefalException("Access", "Right", "Invalid argument");
     73        } catch (ClassCastException e) {
    7774            throw new RefalException("Access", "Right", "Invalid argument");
    7875        }
    7976    }
    8077
    81     @RefalFormat("$func? Middle s.Left s.Right e.Exp = e.SubExp;")
    82     public static boolean Middle (Expr s_left, Expr s_right, Expr e_exp, Result e_subexp) throws RefalException {
    83         assert s_left.length() == 1;
    84         assert s_right.length() == 1;
     78    @RefalFormat("$func? Middle s.left s.right e.expr = e.subExpr;")
     79    public static boolean Middle (Expr left, Expr right, Expr expr, Result subExpr) throws RefalException {
    8580        try {
    86             int left = Util.uintValue((BigInteger) s_left.at(0));
    87             int right = Util.uintValue((BigInteger) s_right.at(0));
    88             if (e_exp.length() < right || left > e_exp.length() - right)
     81            int l = Symbol.uintValue(left);
     82            int r = expr.length() - Symbol.uintValue(right);
     83            if (r < l)
    8984                return false;
    90             e_subexp.assign(e_exp.subexpr(left, e_exp.length() - right - left));
     85            subExpr.assign(expr.subexpr(l, r - l));
    9186            return true;
    92         } catch (Exception e) {
     87        } catch (Util.ValueOutOfBoundsException e) {
     88            throw new RefalException("Access", "Middle", "Invalid argument");
     89        } catch (ClassCastException e) {
    9390            throw new RefalException("Access", "Middle", "Invalid argument");
    9491        }
    9592    }
    9693
    97     @RefalFormat("$func Length e.Exp = s.ExpLen;")
    98     public static void Length (Expr e_exp, Result s_len) {
    99         s_len.assign(BigInteger.valueOf(e_exp.length()));
     94    @RefalFormat("$func Length e.expr = s.length;")
     95    public static void Length (Expr expr, Result length) {
     96        length.assign(Symbol.newInt(expr.length()));
    10097    }
    10198}
  • to-imperative/trunk/java/java/refal/plus/Dos.java

    r3693 r3707  
    1 /*
    2  * $Id$
    3  *
    4  * vim: set syntax=java expandtab shiftwidth=4 tabstop=4:
    5  */
     1// $Id$
    62
    73package refal.plus;
    84
     5import java.lang.String;
    96import java.lang.System;
    107import java.math.BigInteger;
     
    1714import org.refal.plus.RefalRuntime;
    1815import org.refal.plus.Result;
     16import org.refal.plus.Symbol;
    1917import org.refal.plus.Util;
    2018
    2119public class Dos {
    22     private static final java.lang.String[] months = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
    23             "Oct", "Nov", "Dec" };
    24 
     20    private static final String[] months = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
     21            "Nov", "Dec" };
    2522    private static final Character space = new Character(' ');
    2623    private static final Character colon = new Character(':');
    2724    private static final Character point = new Character('.');
    2825
    29     @RefalFormat("$func Time = e.String;")
    30     public static void Time (Result e) {
    31         Calendar c = Calendar.getInstance();
    32         Comparable<?>[] time = { BigInteger.valueOf(c.get(Calendar.DAY_OF_MONTH)), space,
    33                 months[c.get(Calendar.MONTH)], space, BigInteger.valueOf(c.get(Calendar.YEAR)), space,
    34                 BigInteger.valueOf(c.get(Calendar.HOUR_OF_DAY)), colon, BigInteger.valueOf(c.get(Calendar.MINUTE)),
    35                 colon, BigInteger.valueOf(c.get(Calendar.SECOND)), point,
    36                 BigInteger.valueOf(c.get(Calendar.MILLISECOND) / 10) };
    37         e.assign(Expr.fromArray(time));
     26    @RefalFormat("$func Time = e.string;")
     27    public static void Time (Result string) {
     28        Calendar cal = Calendar.getInstance();
     29        string.assign(Expr.getConcatenator(13).toRight(BigInteger.valueOf(cal.get(Calendar.DAY_OF_MONTH))).toRight(
     30                space).toRight(months[cal.get(Calendar.MONTH)]).toRight(space).toRight(
     31                BigInteger.valueOf(cal.get(Calendar.YEAR))).toRight(space).toRight(cal.get(Calendar.HOUR_OF_DAY))
     32                .toRight(colon).toRight(BigInteger.valueOf(cal.get(Calendar.MINUTE))).toRight(colon).toRight(
     33                        BigInteger.valueOf(cal.get(Calendar.SECOND))).toRight(point).toRight(
     34                        BigInteger.valueOf(cal.get(Calendar.MILLISECOND) / 10)).yield());
    3835    }
    3936
    40     @RefalFormat("$func Arg s.Int = e.Arg;")
    41     public static void Arg (Expr e, Result res) throws RefalException {
    42         assert e.length() == 1;
     37    @RefalFormat("$func Arg s.index = e.arg;")
     38    public static void Arg (Expr index, Result arg) throws RefalException {
    4339        try {
    44             int n = Util.uintValue((BigInteger) e.at(0));
    45             if (n >= RefalRuntime.args.length())
    46                 res.assign(Expr.empty);
     40            int n = Symbol.uintValue(index);
     41            if (n < RefalRuntime.args.length())
     42                arg.assign((Expr) RefalRuntime.args.at(n));
    4743            else
    48                 res.assign((Expr) RefalRuntime.args.at(n));
     44                arg.assign(Expr.empty);
    4945        } catch (ClassCastException _) {
    5046            throw new RefalException("Dos", "Arg", "Invalid argument");
    5147        } catch (Util.NegativeValueException _) {
    5248            throw new RefalException("Dos", "Arg", "Invalid argument");
     49        } catch (IndexOutOfBoundsException _) {
     50            throw new RefalException("Vector", "VectorRef", "Index out of range");
    5351        } catch (Util.ValueOutOfBoundsException _) {
    54             res.assign(Expr.empty);
     52            arg.assign(Expr.empty);
    5553        }
    5654    }
    5755
    58     @RefalFormat("$func Args = e.Args;")
     56    @RefalFormat("$func Args = e.args;")
    5957    public static void Args (Result args) {
    6058        args.assign(RefalRuntime.args);
    6159    }
    6260
    63     @RefalFormat("$func GetEnv e.VarName = e.Value;")
    64     public static void GetEnv (Expr var, Result value) {
    65         java.lang.String s = System.getenv(var.toChars().toString());
    66         if (s != null)
    67             value.assign(s);
     61    @RefalFormat("$func GetEnv e.varName = e.value;")
     62    public static void GetEnv (Expr varName, Result value) {
     63        String str = System.getenv(varName.toChars().toString());
     64        if (str != null)
     65            value.assign(str);
    6866        else
    6967            value.assign(Expr.empty);
    7068    }
    7169
    72     @RefalFormat("$func Exit s.ReturnCode = ;")
    73     public static void Exit (Expr e) throws RefalException {
    74         assert e.length() == 1;
     70    @RefalFormat("$func Exit s.returnCode = ;")
     71    public static void Exit (Expr returnCode) throws RefalException {
    7572        try {
    76             System.exit(Util.intValue((BigInteger) e.at(0)));
     73            System.exit(Symbol.intValue(returnCode));
    7774        } catch (ClassCastException _) {
    7875            throw new RefalException("Dos", "Exit", "Invalid argument");
     
    8986    }
    9087
    91     @RefalFormat("$func Random s.Limit = s.Rand;")
     88    @RefalFormat("$func Random s.limit = s.rand;")
    9289    // 0 <= s.Rand < s.Limit
    93     public static void Random (Expr max, Result rand) throws RefalException {
    94         assert max.length() == 1;
     90    public static void Random (Expr limit, Result rand) throws RefalException {
    9591        try {
    96             rand.assign(BigInteger.valueOf(random.nextInt(Util.uintValue((BigInteger) max.at(0)))));
     92            rand.assign(BigInteger.valueOf(random.nextInt(Symbol.uintValue(limit))));
    9793        } catch (ClassCastException _) {
    9894            throw new RefalException("Dos", "Random", "Invalid argument");
     
    10298    }
    10399
    104     @RefalFormat("$func Delay s.Interv = ;")
     100    @RefalFormat("$func Delay s.msec = ;")
    105101    public static void Delay (Expr msec) throws RefalException {
    106         assert msec.length() == 1;
    107102        try {
    108             Thread.sleep(Util.ulongValue(((BigInteger) msec.at(0))));
     103            Thread.sleep(Symbol.ulongValue(msec));
    109104        } catch (ClassCastException _) {
    110             throw new RefalException("Dos", "Delay", "Invalid argument");
    111         } catch (IllegalArgumentException _) {
    112105            throw new RefalException("Dos", "Delay", "Invalid argument");
    113106        } catch (Util.ValueOutOfBoundsException _) {
     
    120113    private static final BigInteger big1000 = BigInteger.valueOf(1000);
    121114
    122     @RefalFormat("$func Sleep s.Interv = ;")
     115    @RefalFormat("$func Sleep s.sec = ;")
    123116    public static void Sleep (Expr sec) throws RefalException {
    124         assert sec.length() == 1;
    125117        try {
    126             Thread.sleep(Util.ulongValue(((BigInteger) sec.at(0)).multiply(big1000)));
     118            Thread.sleep(Util.ulongValue(Symbol.getBigInteger(sec).multiply(big1000)));
    127119        } catch (ClassCastException _) {
    128             throw new RefalException("Dos", "Sleep", "Invalid argument");
    129         } catch (IllegalArgumentException _) {
    130120            throw new RefalException("Dos", "Sleep", "Invalid argument");
    131121        } catch (Util.ValueOutOfBoundsException _) {
  • to-imperative/trunk/java/java/refal/plus/Table.java

    r3705 r3707  
    88import org.refal.plus.Result;
    99import org.refal.plus.Symbol;
    10 import org.refal.plus.Util;
    1110
    1211public final class Table {
     
    122121    public static void TableSize (Expr table, Result size) throws RefalException {
    123122        try {
    124             size.assign(Util.bigIntegerValue(Symbol.getTable(table).size()));
     123            size.assign(Symbol.newInt(Symbol.getTable(table).size()));
    125124        } catch (ClassCastException _) {
    126125            throw new RefalException("Table", "TableSize", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/Vector.java

    r3705 r3707  
    99import org.refal.plus.Symbol;
    1010import org.refal.plus.Util;
     11import org.refal.plus.Util.NegativeValueException;
     12import org.refal.plus.Util.ValueOutOfBoundsException;
    1113
    1214public final class Vector {
     
    4042            org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
    4143            vec.clear();
    42             int s = Util.uintValue(len);
     44            int s = Symbol.uintValue(len);
    4345            for (int i = 0; i < s; i++)
    4446                vec.add(fill);
    45         } catch (Util.NegativeValueException _) {
     47        } catch (NegativeValueException _) {
    4648            throw new RefalException("Vector", "VectorInit", "Invalid argument");
    47         } catch (Util.ValueOutOfBoundsException _) {
     49        } catch (ValueOutOfBoundsException _) {
    4850            throw new RefalException("Vector", "VectorInit", "Size limit exceeded");
    4951        } catch (ClassCastException _) {
     
    6769    public static void VectorLength (Expr vector, Result length) throws RefalException {
    6870        try {
    69             length.assign(Util.bigIntegerValue(Symbol.getVector(vector).size()));
     71            length.assign(Symbol.newInt(Symbol.getVector(vector).size()));
    7072        } catch (ClassCastException _) {
    7173            throw new RefalException("Vector", "VectorLength", "Invalid argument");
     
    7678    public static void VectorRef (Expr vector, Expr index, Result expr) throws RefalException {
    7779        try {
    78             expr.assign(Symbol.getVector(vector).get(Util.uintValue(index)));
    79         } catch (Util.NegativeValueException _) {
     80            expr.assign(Symbol.getVector(vector).get(Symbol.uintValue(index)));
     81        } catch (NegativeValueException _) {
    8082            throw new RefalException("Vector", "VectorRef", "Invalid argument");
    81         } catch (Util.ValueOutOfBoundsException _) {
     83        } catch (ValueOutOfBoundsException _) {
    8284            throw new RefalException("Vector", "VectorRef", "Index out of range");
    8385        } catch (IndexOutOfBoundsException _) {
     
    9193    public static void VectorSet (Expr vector, Expr index, Expr expr) throws RefalException {
    9294        try {
    93             Symbol.getVector(vector).set(Util.uintValue(index), expr);
    94         } catch (Util.NegativeValueException _) {
     95            Symbol.getVector(vector).set(Symbol.uintValue(index), expr);
     96        } catch (NegativeValueException _) {
    9597            throw new RefalException("Vector", "VectorSet", "Invalid argument");
    96         } catch (Util.ValueOutOfBoundsException _) {
     98        } catch (ValueOutOfBoundsException _) {
    9799            throw new RefalException("Vector", "VectorSet", "Index out of range");
    98100        } catch (IndexOutOfBoundsException _) {
     
    117119    public static void Subvector (Expr vector, Expr index, Expr length, Result subVector) throws RefalException {
    118120        try {
    119             int s = Util.uintValue(index);
    120             int e = s + Util.uintValue(length);
     121            int s = Symbol.uintValue(index);
     122            int e = s + Symbol.uintValue(length);
    121123            Symbol.setToResult(Symbol.getVector(vector).subVector(s, e), subVector);
    122124        } catch (Util.NegativeValueException _) {
     
    135137        try {
    136138            org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
    137             int s = Util.uintValue(index);
    138             int e = s + Util.uintValue(length);
     139            int s = Symbol.uintValue(index);
     140            int e = s + Symbol.uintValue(length);
    139141            for (int i = s; i < e; i++)
    140142                vec.set(i, fill);
Note: See TracChangeset for help on using the changeset viewer.