Changeset 3725


Ignore:
Timestamp:
Apr 17, 2008, 6:24:30 PM (13 years ago)
Author:
yura
Message:
  • Specific object functions are moved from Symbol class to libraries classes.
  • Integer functions are moved from Symbol to Util.
  • Reference is not generic class.
Location:
to-imperative/trunk/java/java
Files:
20 edited

Legend:

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

    r3724 r3725  
    359359    public String toString () {
    360360        StringBuffer strBuf = new StringBuffer();
    361         toStringBuffer(strBuf);
     361        toString(strBuf);
    362362        return strBuf.toString();
    363363    }
    364364
    365     private void toStringBuffer (StringBuffer strBuf) {
     365    private void toString (StringBuffer strBuf) {
    366366        boolean chars = false;
    367367        boolean isNotFirst = false;
     
    407407            if (term instanceof Expr) {
    408408                strBuf.append('(');
    409                 ((Expr) term).toStringBuffer(strBuf);
     409                ((Expr) term).toString(strBuf);
    410410                strBuf.append(')');
    411411            } else if (term instanceof String) {
     
    434434            if (term instanceof Expr) {
    435435                strBuf.append('(');
    436                 ((Expr) term).toStringBuffer(strBuf);
     436                ((Expr) term).toString(strBuf);
    437437                strBuf.append(')');
    438             } else if (term instanceof Reference && ((Reference) term).object instanceof StringBuffer)
    439                 strBuf.append(((Reference<StringBuffer>) term).object);
     438            } else if (term instanceof Reference && ((Reference) term).object instanceof org.refal.plus.objects.String)
     439                ((org.refal.plus.objects.String) ((Reference) term).object).toExpr().toChars(strBuf);
    440440            else
    441441                strBuf.append(term.toString());
  • to-imperative/trunk/java/java/org/refal/plus/Native.java

    r3722 r3725  
    4040
    4141    public static Comparable<?> sValueOf (Object obj) {
    42         return obj instanceof Comparable ? (Comparable<?>) obj : new Reference<Object>(obj);
     42        return obj instanceof Comparable ? (Comparable<?>) obj : new Reference(obj);
    4343    }
    4444
     
    128128    @Deprecated
    129129    public static Object objectValue (Comparable<?> term) {
    130         return term instanceof Reference ? ((Reference<?>) term).object : term;
     130        return term instanceof Reference ? ((Reference) term).object : term;
    131131    }
    132132
  • to-imperative/trunk/java/java/org/refal/plus/Reference.java

    r3686 r3725  
    77package org.refal.plus;
    88
    9 public class Reference<T> implements Comparable<Reference<?>> {
     9public class Reference implements Comparable<Reference> {
    1010    private final String name;
    1111
    12     public final T object;
     12    public final Object object;
    1313
    14     public Reference (String name, T obj) {
     14    public Reference (String name, Object obj) {
    1515        this.name = name;
    1616        this.object = obj;
    1717    }
    1818
    19     public Reference (T obj) {
     19    public Reference (Object obj) {
    2020        this(null, obj);
    2121    }
     
    2323    @Override
    2424    public boolean equals (Object obj) {
    25         return (obj instanceof Reference) && object == ((Reference<?>) obj).object;
     25        return (obj instanceof Reference) && object == ((Reference) obj).object;
    2626    }
    2727
     
    3939    }
    4040
    41     public int compareTo (Reference<?> ref) {
     41    public int compareTo (Reference ref) {
    4242        return RefalRuntime.compare(this, ref);
    4343    }
  • to-imperative/trunk/java/java/org/refal/plus/Symbol.java

    r3724 r3725  
    1414    private Symbol () {}
    1515
    16     public static final Comparable<?> null_object = new Reference<Object>(null);
     16    public static final Comparable<?> nullTerm = new Reference(null);
    1717
    1818    public static Comparable<?> newInt (long i) {
     
    2929
    3030    public static Comparable<?> newBox (String name) {
    31         return new Reference<Box>(name, new Box());
     31        return new Reference(name, new Box());
    3232    }
    3333
    3434    public static Comparable<?> newChannel (String name) {
    35         return new Reference<Channel>(name, new Channel());
     35        return new Reference(name, new Channel());
    3636    }
    3737
    3838    public static Comparable<?> newFunc (String name, Func func) {
    39         return new Reference<Func>(name, func);
     39        return new Reference(name, func);
    4040    }
    4141
    4242    public static Comparable<?> newString (String name) {
    43         return new Reference<org.refal.plus.objects.String>(name, new org.refal.plus.objects.String());
     43        return new Reference(name, new org.refal.plus.objects.String());
    4444    }
    4545
    4646    public static Comparable<?> newTable (String name) {
    47         return new Reference<Table>(name, new Table());
     47        return new Reference(name, new Table());
    4848    }
    4949
    5050    public static Comparable<?> newVector (String name) {
    51         return new Reference<Vector>(name, new Vector());
     51        return new Reference(name, new Vector());
    5252    }
    5353
    54 
    55 
    56     public static Box getBox (Expr expr) throws ClassCastException {
    57         return (Box) getObject(expr);
    58     }
    59 
    60     public static Channel getChannel (Expr expr) throws ClassCastException {
    61         return (Channel) getObject(expr);
    62     }
    63 
    64     public static Table getTable (Expr expr) throws ClassCastException {
    65         return (Table) getObject(expr);
    66     }
    67 
    68     public static Vector getVector (Expr expr) throws ClassCastException {
    69         return (Vector) getObject(expr);
    70     }
    71 
    72     public static org.refal.plus.objects.String getString (Expr expr) throws ClassCastException {
    73         return (org.refal.plus.objects.String) getObject(expr);
    74     }
    75 
    76     public static Func getFunc (Expr expr) throws ClassCastException {
    77         return (Func) getObject(expr);
    78     }
    79 
    80 
    81    
    82     public static <T> void setToResult (T object, Result res) {
    83         res.assign(new Reference<T>(object));
    84     }
    85 
    86     public static BigInteger getBigInteger (Expr expr) throws ClassCastException {
    87         return (BigInteger) getTerm(expr);
    88     }
    89 
    90     public static Character getCharacter (Expr expr) throws ClassCastException {
    91         return (Character) getTerm(expr);
    92     }
    93 
    94     public static int intValue (Expr expr) throws ClassCastException, Util.ValueOutOfBoundsException {
    95         return Util.intValue(getBigInteger(expr));
    96     }
    97 
    98     public static int uintValue (Expr expr) throws ClassCastException, Util.NegativeValueException,
    99             Util.ValueOutOfBoundsException {
    100         return Util.uintValue(getBigInteger(expr));
    101     }
    102 
    103     public static long ulongValue (Expr expr) throws ClassCastException, Util.NegativeValueException,
    104             Util.ValueOutOfBoundsException {
    105         return Util.ulongValue(getBigInteger(expr));
    106     }
    107 
    108     static Comparable<?> getTerm (Expr expr) {
     54    public static Comparable<?> getTerm (Expr expr) {
    10955        assert expr.length() == 1;
    11056        return expr.at(0);
    11157    }
    11258
    113     static Object getObject (Expr expr) throws ClassCastException {
    114         return ((Reference<?>) getTerm(expr)).object;
     59    public static Object getObject (Comparable<?> term) throws ClassCastException {
     60        return ((Reference) term).object;
     61    }
     62
     63    public static Object getObject (Expr expr) throws ClassCastException {
     64        return getObject(getTerm(expr));
     65    }
     66
     67    public static <T> void setObject (T object, Result res) {
     68        res.assign(new Reference(object));
    11569    }
    11670}
  • to-imperative/trunk/java/java/org/refal/plus/Util.java

    r3707 r3725  
    1717    }
    1818
     19    public static BigInteger getBigInteger (Expr expr) throws ClassCastException {
     20        return (BigInteger) Symbol.getTerm(expr);
     21    }
     22
    1923    private static final BigInteger minInt = BigInteger.valueOf(Integer.MIN_VALUE);
    2024    private static final BigInteger maxInt = BigInteger.valueOf(Integer.MAX_VALUE);
     
    2630    }
    2731
    28     public static int uintValue (BigInteger bigInt) throws ValueOutOfBoundsException {
     32    public static int intValue (Expr expr) throws ClassCastException, ValueOutOfBoundsException {
     33        return intValue(getBigInteger(expr));
     34    }
     35
     36    public static int uintValue (BigInteger bigInt) throws NegativeValueException, ValueOutOfBoundsException {
    2937        if (bigInt.compareTo(BigInteger.ZERO) < 0)
    3038            throw new NegativeValueException();
     
    3240            throw new ValueOutOfBoundsException();
    3341        return bigInt.intValue();
     42    }
     43
     44    public static int uintValue (Expr expr) throws ClassCastException, NegativeValueException,
     45            ValueOutOfBoundsException {
     46        return uintValue(getBigInteger(expr));
    3447    }
    3548
     
    4356    }
    4457
    45     public static long ulongValue (BigInteger bigInt) throws ValueOutOfBoundsException {
     58    public static long ulongValue (BigInteger bigInt) throws NegativeValueException, ValueOutOfBoundsException {
    4659        if (bigInt.compareTo(BigInteger.ZERO) < 0)
    4760            throw new NegativeValueException();
     
    5063        return bigInt.longValue();
    5164    }
     65
     66    public static long ulongValue (Expr expr) throws ClassCastException, NegativeValueException,
     67            ValueOutOfBoundsException {
     68        return ulongValue(getBigInteger(expr));
     69    }
    5270}
  • to-imperative/trunk/java/java/org/refal/plus/objects/String.java

    r3718 r3725  
    66
    77import org.refal.plus.Expr;
    8 import org.refal.plus.Reference;
     8import org.refal.plus.Symbol;
    99
    1010public final class String extends ArrayList<Character> {
     
    1616                add((Character) term);
    1717            else
    18                 addAll((String) ((Reference<?>) term).object);
     18                addAll((String) Symbol.getObject(term));
    1919    }
    2020
  • to-imperative/trunk/java/java/org/refal/plus/objects/Vector.java

    r3721 r3725  
    66
    77import org.refal.plus.Expr;
    8 import org.refal.plus.Reference;
     8import org.refal.plus.Symbol;
    99
    1010public final class Vector extends ArrayList<Expr> {
     
    1616                add((Expr) term);
    1717            else
    18                 addAll((Vector) ((Reference<?>) term).object);
     18                addAll((Vector) Symbol.getObject(term));
    1919    }
    2020
  • to-imperative/trunk/java/java/refal/plus/Access.java

    r3707 r3725  
    1717    public static boolean L (Expr left, Expr expr, Result subTerm) throws RefalException {
    1818        try {
    19             int l = Symbol.uintValue(left);
     19            int l = Util.uintValue(left);
    2020            if (expr.length() <= l)
    2121                return false;
     
    3232    public static boolean R (Expr right, Expr expr, Result subTerm) throws RefalException {
    3333        try {
    34             int r = expr.length() - Symbol.uintValue(right);
     34            int r = expr.length() - Util.uintValue(right);
    3535            if (r <= 0)
    3636                return false;
     
    4747    public static boolean Left (Expr left, Expr length, Expr expr, Result subExpr) throws RefalException {
    4848        try {
    49             int l = Symbol.uintValue(left);
    50             int len = Symbol.uintValue(length);
     49            int l = Util.uintValue(left);
     50            int len = Util.uintValue(length);
    5151            if (expr.length() - len < l)
    5252                return false;
     
    6363    public static boolean Right (Expr right, Expr length, Expr expr, Result subExpr) throws RefalException {
    6464        try {
    65             int r = expr.length() - Symbol.uintValue(right);
    66             int len = Symbol.uintValue(length);
     65            int r = expr.length() - Util.uintValue(right);
     66            int len = Util.uintValue(length);
    6767            if (r < len)
    6868                return false;
     
    7979    public static boolean Middle (Expr left, Expr right, Expr expr, Result subExpr) throws RefalException {
    8080        try {
    81             int l = Symbol.uintValue(left);
    82             int r = expr.length() - Symbol.uintValue(right);
     81            int l = Util.uintValue(left);
     82            int r = expr.length() - Util.uintValue(right);
    8383            if (r < l)
    8484                return false;
  • to-imperative/trunk/java/java/refal/plus/Apply.java

    r3713 r3725  
    44
    55import org.refal.plus.Expr;
     6import org.refal.plus.Func;
    67import org.refal.plus.RefalException;
    78import org.refal.plus.RefalFormat;
     
    1718    public static boolean Apply (Expr func, Expr arg, Result res) throws RefalException {
    1819        try {
    19             return Symbol.getFunc(func).eval(arg, res);
     20            return ((Func) Symbol.getObject(func)).eval(arg, res);
    2021        } catch (ClassCastException e) {
    2122            throw new RefalException("Apply", "Apply", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/Arithm.java

    r3708 r3725  
    99import org.refal.plus.RefalFormat;
    1010import org.refal.plus.Result;
    11 import org.refal.plus.Symbol;
     11import org.refal.plus.Util;
    1212
    1313public final class Arithm {
     
    1818    public static void Add (Expr int1, Expr int2, Result res) throws RefalException {
    1919        try {
    20             res.assign(Symbol.getBigInteger(int1).add(Symbol.getBigInteger(int2)));
     20            res.assign(Util.getBigInteger(int1).add(Util.getBigInteger(int2)));
    2121        } catch (ClassCastException e) {
    2222            throw new RefalException("Arithm", "Add", "Invalid argument");
     
    2727    public static void Sub (Expr int1, Expr int2, Result res) throws RefalException {
    2828        try {
    29             res.assign(Symbol.getBigInteger(int1).subtract(Symbol.getBigInteger(int2)));
     29            res.assign(Util.getBigInteger(int1).subtract(Util.getBigInteger(int2)));
    3030        } catch (ClassCastException e) {
    3131            throw new RefalException("Arithm", "Sub", "Invalid argument");
     
    3636    public static void Mult (Expr int1, Expr int2, Result res) throws RefalException {
    3737        try {
    38             res.assign(Symbol.getBigInteger(int1).multiply(Symbol.getBigInteger(int2)));
     38            res.assign(Util.getBigInteger(int1).multiply(Util.getBigInteger(int2)));
    3939        } catch (ClassCastException e) {
    4040            throw new RefalException("Arithm", "Mult", "Invalid argument");
     
    4545    public static void Div (Expr int1, Expr int2, Result quo) throws RefalException {
    4646        try {
    47             quo.assign(Symbol.getBigInteger(int1).divide(Symbol.getBigInteger(int2)));
     47            quo.assign(Util.getBigInteger(int1).divide(Util.getBigInteger(int2)));
    4848        } catch (ArithmeticException e) {
    4949            throw new RefalException("Arithm", "Div", "Divide by zero");
     
    5656    public static void Rem (Expr int1, Expr int2, Result rem) throws RefalException {
    5757        try {
    58             rem.assign(Symbol.getBigInteger(int1).remainder(Symbol.getBigInteger(int2)));
     58            rem.assign(Util.getBigInteger(int1).remainder(Util.getBigInteger(int2)));
    5959        } catch (ArithmeticException e) {
    6060            throw new RefalException("Arithm", "Div", "Divide by zero");
     
    6767    public static void DivRem (Expr int1, Expr int2, Result quo, Result rem) throws RefalException {
    6868        try {
    69             BigInteger[] a = Symbol.getBigInteger(int1).divideAndRemainder(Symbol.getBigInteger(int2));
     69            BigInteger[] a = Util.getBigInteger(int1).divideAndRemainder(Util.getBigInteger(int2));
    7070            quo.assign(a[0]);
    7171            rem.assign(a[1]);
     
    8080    public static void Gcd (Expr int1, Expr int2, Result gcd) throws RefalException {
    8181        try {
    82             BigInteger d = Symbol.getBigInteger(int1).gcd(Symbol.getBigInteger(int2));
     82            BigInteger d = Util.getBigInteger(int1).gcd(Util.getBigInteger(int2));
    8383            if (d.equals(BigInteger.ZERO))
    8484                throw new RefalException("Arithm", "Gcd", "Zero arguments");
     
    9292    public static void Abs (Expr int1, Result res) throws RefalException {
    9393        try {
    94             res.assign((Symbol.getBigInteger(int1)).abs());
     94            res.assign(Util.getBigInteger(int1).abs());
    9595        } catch (ClassCastException e) {
    9696            throw new RefalException("Arithm", "Gcd", "Invalid argument");
     
    101101    public static void Max (Expr int1, Expr int2, Result max) throws RefalException {
    102102        try {
    103             max.assign(Symbol.getBigInteger(int1).max(Symbol.getBigInteger(int2)));
     103            max.assign(Util.getBigInteger(int1).max(Util.getBigInteger(int2)));
    104104        } catch (ClassCastException e) {
    105105            throw new RefalException("Arithm", "Max", "Invalid argument");
     
    110110    public static void Min (Expr int1, Expr int2, Result min) throws RefalException {
    111111        try {
    112             min.assign(Symbol.getBigInteger(int1).min(Symbol.getBigInteger(int2)));
     112            min.assign(Util.getBigInteger(int1).min(Util.getBigInteger(int2)));
    113113        } catch (ClassCastException e) {
    114114            throw new RefalException("Arithm", "Min", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/Bit.java

    r3708 r3725  
    99import org.refal.plus.RefalFormat;
    1010import org.refal.plus.Result;
    11 import org.refal.plus.Symbol;
     11import org.refal.plus.Util;
    1212import org.refal.plus.Util.ValueOutOfBoundsException;
    1313
     
    1919    public static void BitAnd (Expr int1, Expr int2, Result res) throws RefalException {
    2020        try {
    21             res.assign(Symbol.getBigInteger(int1).and(Symbol.getBigInteger(int2)));
     21            res.assign(Util.getBigInteger(int1).and(Util.getBigInteger(int2)));
    2222        } catch (ClassCastException _) {
    2323            throw new RefalException("Bit", "BitAnd", "Invalid argument");
     
    2828    public static void BitOr (Expr int1, Expr int2, Result res) throws RefalException {
    2929        try {
    30             res.assign(Symbol.getBigInteger(int1).or(Symbol.getBigInteger(int2)));
     30            res.assign(Util.getBigInteger(int1).or(Util.getBigInteger(int2)));
    3131        } catch (ClassCastException _) {
    3232            throw new RefalException("Bit", "BitOr", "Invalid argument");
     
    3737    public static void BitXor (Expr int1, Expr int2, Result res) throws RefalException {
    3838        try {
    39             res.assign(Symbol.getBigInteger(int1).xor(Symbol.getBigInteger(int2)));
     39            res.assign(Util.getBigInteger(int1).xor(Util.getBigInteger(int2)));
    4040        } catch (ClassCastException _) {
    4141            throw new RefalException("Bit", "BitXor", "Invalid argument");
     
    4646    public static void BitNot (Expr int1, Result res) throws RefalException {
    4747        try {
    48             res.assign(Symbol.getBigInteger(int1).not());
     48            res.assign(Util.getBigInteger(int1).not());
    4949        } catch (ClassCastException _) {
    5050            throw new RefalException("Bit", "BitNot", "Invalid argument");
     
    5555    public static void BitLeft (Expr int1, Expr shift, Result res) throws RefalException {
    5656        try {
    57             res.assign(Symbol.getBigInteger(int1).shiftLeft(Symbol.intValue(shift)));
     57            res.assign(Util.getBigInteger(int1).shiftLeft(Util.intValue(shift)));
    5858        } catch (ValueOutOfBoundsException _) {
    5959            throw new RefalException("Bit", "BitLeft", "Invalid argument");
     
    6666    public static void BitRight (Expr int1, Expr shift, Result res) throws RefalException {
    6767        try {
    68             res.assign(Symbol.getBigInteger(int1).shiftRight(Symbol.intValue(shift)));
     68            res.assign(Util.getBigInteger(int1).shiftRight(Util.intValue(shift)));
    6969        } catch (ValueOutOfBoundsException _) {
    7070            throw new RefalException("Bit", "BitRight", "Invalid argument");
     
    7777    public static boolean BitTest (Expr int1, Expr pos) throws RefalException {
    7878        try {
    79             return Symbol.getBigInteger(int1).testBit(Symbol.uintValue(pos));
     79            return Util.getBigInteger(int1).testBit(Util.uintValue(pos));
    8080        } catch (ValueOutOfBoundsException _) {
    8181            throw new RefalException("Bit", "BitLeft", "Invalid argument");
     
    8888    public static void BitSet (Expr int1, Expr pos, Result res) throws RefalException {
    8989        try {
    90             res.assign(Symbol.getBigInteger(int1).setBit(Symbol.uintValue(pos)));
     90            res.assign(Util.getBigInteger(int1).setBit(Util.uintValue(pos)));
    9191        } catch (ValueOutOfBoundsException _) {
    9292            throw new RefalException("Bit", "BitSet", "Invalid argument");
     
    9999    public static void BitClear (Expr int1, Expr pos, Result res) throws RefalException {
    100100        try {
    101             res.assign(Symbol.getBigInteger(int1).clearBit(Symbol.uintValue(pos)));
     101            res.assign(Util.getBigInteger(int1).clearBit(Util.uintValue(pos)));
    102102        } catch (ValueOutOfBoundsException _) {
    103103            throw new RefalException("Bit", "BitClear", "Invalid argument");
     
    110110    public static void BitLength (Expr int1, Result len) throws RefalException {
    111111        try {
    112             len.assign(BigInteger.valueOf(Symbol.getBigInteger(int1).bitLength()));
     112            len.assign(BigInteger.valueOf(Util.getBigInteger(int1).bitLength()));
    113113        } catch (ClassCastException _) {
    114114            throw new RefalException("Bit", "BitLength", "Invalid argument");
     
    119119    public static void BitToHex (Expr int1, Result hex) throws RefalException {
    120120        try {
    121             BigInteger i = Symbol.getBigInteger(int1);
     121            BigInteger i = Util.getBigInteger(int1);
    122122            hex.assign((i.compareTo(BigInteger.ZERO) >= 0 ? "0x" + i.toString(16) : "-0x" + i.abs().toString(16)));
    123123        } catch (ClassCastException _) {
  • to-imperative/trunk/java/java/refal/plus/Box.java

    r3724 r3725  
    1313    private Box () {}
    1414
     15    static org.refal.plus.objects.Box getBox (Expr expr) throws ClassCastException {
     16        return (org.refal.plus.objects.Box) Symbol.getObject(expr);
     17    }
     18
    1519    @SuppressWarnings("all")
    1620    @RefalFormat("$func Box e.expr = s.box;")
     
    1822        org.refal.plus.objects.Box b = new org.refal.plus.objects.Box();
    1923        b.expr = expr;
    20         Symbol.setToResult(b, box);
     24        Symbol.setObject(b, box);
    2125    }
    2226
     
    2428    public static void Get (Expr box, Result expr) throws RefalException {
    2529        try {
    26             expr.assign(Symbol.getBox(box).expr);
     30            expr.assign(getBox(box).expr);
    2731        } catch (ClassCastException _) {
    2832            throw new RefalException("Box", "Get", "Invalid argument");
     
    3438        assert box.length() == 1;
    3539        try {
    36             Symbol.getBox(box).expr = expr;
     40            getBox(box).expr = expr;
    3741        } catch (ClassCastException _) {
    3842            throw new RefalException("Box", "Store", "Invalid argument");
     
    4246    @RefalFormat("$func Put s.box e.expr = ;")
    4347    public static void Put (Expr box, Expr expr) throws RefalException {
    44         org.refal.plus.objects.Box b = Symbol.getBox(box);
     48        org.refal.plus.objects.Box b = getBox(box);
    4549        b.expr = Expr.concat(b.expr, expr);
    4650    }
     51
    4752}
  • to-imperative/trunk/java/java/refal/plus/Class.java

    r3722 r3725  
    3030        Comparable<?> term = isTerm(expr);
    3131        if (term instanceof Reference)
    32             return ((Reference<?>) term).object;
     32            return ((Reference) term).object;
    3333        return null;
    3434    }
  • to-imperative/trunk/java/java/refal/plus/Dos.java

    r3721 r3725  
    1212import org.refal.plus.RefalRuntime;
    1313import org.refal.plus.Result;
    14 import org.refal.plus.Symbol;
    1514import org.refal.plus.Util;
    1615
     
    3635    public static void Arg (Expr index, Result arg) throws RefalException {
    3736        try {
    38             int n = Symbol.uintValue(index);
     37            int n = Util.uintValue(index);
    3938            if (n < RefalRuntime.args.length())
    4039                arg.assign((Expr) RefalRuntime.args.at(n));
     
    6968    public static void Exit (Expr returnCode) throws RefalException {
    7069        try {
    71             java.lang.System.exit(Symbol.intValue(returnCode));
     70            java.lang.System.exit(Util.intValue(returnCode));
    7271        } catch (ClassCastException _) {
    7372            throw new RefalException("Dos", "Exit", "Invalid argument");
     
    8887    public static void Random (Expr limit, Result rand) throws RefalException {
    8988        try {
    90             rand.assign(BigInteger.valueOf(random.nextInt(Symbol.uintValue(limit))));
     89            rand.assign(BigInteger.valueOf(random.nextInt(Util.uintValue(limit))));
    9190        } catch (ClassCastException _) {
    9291            throw new RefalException("Dos", "Random", "Invalid argument");
     
    9998    public static void Delay (Expr msec) throws RefalException {
    10099        try {
    101             Thread.sleep(Symbol.ulongValue(msec));
     100            Thread.sleep(Util.ulongValue(msec));
    102101        } catch (ClassCastException _) {
    103102            throw new RefalException("Dos", "Delay", "Invalid argument");
     
    114113    public static void Sleep (Expr sec) throws RefalException {
    115114        try {
    116             Thread.sleep(Util.ulongValue(Symbol.getBigInteger(sec).multiply(big1000)));
     115            Thread.sleep(Util.ulongValue(Util.getBigInteger(sec).multiply(big1000)));
    117116        } catch (ClassCastException _) {
    118117            throw new RefalException("Dos", "Sleep", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/File.java

    r3724 r3725  
    2424   
    2525    static {
    26         Symbol.getBox(PathSeparator).expr = new Expr(new Character(java.io.File.pathSeparatorChar));
    27         Symbol.getBox(DirSeparator).expr = new Expr(new Character(java.io.File.separatorChar));
     26        Box.getBox(PathSeparator).expr = new Expr(new Character(java.io.File.pathSeparatorChar));
     27        Box.getBox(DirSeparator).expr = new Expr(new Character(java.io.File.separatorChar));
    2828    }
    2929
  • to-imperative/trunk/java/java/refal/plus/Java.java

    r3423 r3725  
    1 /*
    2  * $Id$
    3  *
    4  * vim: set syntax=java expandtab shiftwidth=4 tabstop=4:
    5  */
     1// $Id$
    62
    73package refal.plus;
     
    1612    private Java () {}
    1713
    18     private static Expr null_expr = new Expr(Symbol.null_object);
     14    private static Expr nullExpr = new Expr(Symbol.nullTerm);
    1915
    2016    @RefalFormat("$func Null = s;")
    2117    public static void Null (Result res) {
    22         res.assign(null_expr);
     18        res.assign(nullExpr);
    2319    }
    2420}
  • to-imperative/trunk/java/java/refal/plus/StdIO.java

    r3724 r3725  
    1212import org.refal.plus.Result;
    1313import org.refal.plus.Symbol;
    14 
    15 public class StdIO {
     14import org.refal.plus.objects.Channel;
     15
     16public final class StdIO {
     17    /** Don't let anyone instantiate this class */
     18    private StdIO () {}
     19
     20    private static Channel getChannel (Expr expr) throws ClassCastException {
     21        return (Channel) Symbol.getObject(expr);
     22    }
     23
    1624    @RefalFormat("$channel StdIn;")
    1725    public static final Expr StdIn = new Expr(Symbol.newChannel("StdIn"));
     
    2432   
    2533    static {
    26         Symbol.getChannel(StdIn).set(java.lang.System.in);
    27         Symbol.getChannel(StdOut).set(java.lang.System.out);
    28         Symbol.getChannel(StdErr).set(java.lang.System.err);
     34        getChannel(StdIn).set(java.lang.System.in);
     35        getChannel(StdOut).set(java.lang.System.out);
     36        getChannel(StdErr).set(java.lang.System.err);
    2937    }
    3038
    3139    @RefalFormat("$func Channel = s.channel;")
    3240    public static void Channel (Result channel) {
    33         Symbol.setToResult(new org.refal.plus.objects.Channel(), channel);
     41        Symbol.setObject(new Channel(), channel);
    3442    }
    3543
     
    3947            java.lang.String m = mode.at(0).toString();
    4048            if (m.equalsIgnoreCase("r"))
    41                 Symbol.getChannel(channel).openFileReader(file.toChars().toString());
     49                getChannel(channel).openFileReader(file.toChars().toString());
    4250            else if (m.equalsIgnoreCase("w"))
    43                 Symbol.getChannel(channel).openFileWriter(file.toChars().toString(), false);
     51                getChannel(channel).openFileWriter(file.toChars().toString(), false);
    4452            else if (m.equalsIgnoreCase("a"))
    45                 Symbol.getChannel(channel).openFileWriter(file.toChars().toString(), true);
     53                getChannel(channel).openFileWriter(file.toChars().toString(), true);
    4654            else
    4755                return false;
     
    5563    public static void PrimCloseChannel (Expr channel) throws RefalException {
    5664        try {
    57             Symbol.getChannel(channel).close();
     65            getChannel(channel).close();
    5866        } catch (IOException x) {
    5967            java.lang.String s = x.getMessage();
     
    6876            int n = ((BigInteger) len.at(0)).intValue();
    6977            char[] buf = new char[n];
    70             n = Symbol.getChannel(channel).read(buf, 0, n);
     78            n = getChannel(channel).read(buf, 0, n);
    7179            if (n == -1)
    7280                return false;
     
    95103    public static void WriteCh (Expr channel, Expr e) throws RefalException {
    96104        try {
    97             Symbol.getChannel(channel).print(e.toString());
     105            getChannel(channel).print(e.toString());
    98106        } catch (ClassCastException _) {
    99107            throw new RefalException("StdIO", "WriteCh", "Invalid argument");
     
    107115    public static void WriteLnCh (Expr channel, Expr e) throws RefalException {
    108116        try {
    109             Symbol.getChannel(channel).println(e.toString());
     117            getChannel(channel).println(e.toString());
    110118        } catch (ClassCastException _) {
    111119            throw new RefalException("StdIO", "WriteLnCh", "Invalid argument");
     
    129137    public static void PrintCh (Expr channel, Expr e) throws RefalException {
    130138        try {
    131             Symbol.getChannel(channel).print(e.toChars());
     139            getChannel(channel).print(e.toChars());
    132140        } catch (ClassCastException _) {
    133141            throw new RefalException("StdIO", "PrintCh", "Invalid argument");
     
    141149    public static void PrintLnCh (Expr channel, Expr e) throws RefalException {
    142150        try {
    143             Symbol.getChannel(channel).println(e.toChars());
     151            getChannel(channel).println(e.toChars());
    144152        } catch (ClassCastException _) {
    145153            throw new RefalException("StdIO", "PrintLnCh", "Invalid argument");
     
    153161    public static void Flush (Expr channel) throws RefalException {
    154162        try {
    155             Symbol.getChannel(channel).flush();
     163            getChannel(channel).flush();
    156164        } catch (ClassCastException _) {
    157165            throw new RefalException("StdIO", "Flush", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/String.java

    r3719 r3725  
    88import org.refal.plus.Result;
    99import org.refal.plus.Symbol;
     10import org.refal.plus.Util;
    1011import org.refal.plus.Util.NegativeValueException;
    1112import org.refal.plus.Util.ValueOutOfBoundsException;
     
    1516    private String () {}
    1617
     18    private static org.refal.plus.objects.String getString (Expr expr) throws ClassCastException {
     19        return (org.refal.plus.objects.String) Symbol.getObject(expr);
     20    }
     21
     22    private static Character getCharacter (Expr expr) throws ClassCastException {
     23        return (Character) Symbol.getTerm(expr);
     24    }
     25
     26
    1727    @SuppressWarnings("all")
    1828    @RefalFormat("$func String e.source = s.string;")
     
    2131            org.refal.plus.objects.String str = new org.refal.plus.objects.String();
    2232            str.init(source);
    23             Symbol.setToResult(str, string);
     33            Symbol.setObject(str, string);
    2434        } catch (ClassCastException _) {
    2535            throw new RefalException("String", "String", "Invalid argument");
     
    3040    public static void StringToExp (Expr string, Result expr) throws RefalException {
    3141        try {
    32             expr.assign(Symbol.getString(string).toExpr());
     42            expr.assign(getString(string).toExpr());
    3343        } catch (ClassCastException _) {
    3444            throw new RefalException("Vector", "Vector", "Invalid argument");
     
    3949    public static void StringInit (Expr string, Expr lenght, Expr ch) throws RefalException {
    4050        try {
    41             org.refal.plus.objects.String str = Symbol.getString(string);
    42             int s = Symbol.uintValue(lenght);
    43             Character c = Symbol.getCharacter(ch);
     51            org.refal.plus.objects.String str = getString(string);
     52            int s = Util.uintValue(lenght);
     53            Character c = getCharacter(ch);
    4454            str.clear();
    4555            for (int i = 0; i < s; i++)
     
    5767    public static void StringFill (Expr string, Expr ch) throws RefalException {
    5868        try {
    59             org.refal.plus.objects.String str = Symbol.getString(string);
    60             Character c = Symbol.getCharacter(ch);
     69            org.refal.plus.objects.String str = getString(string);
     70            Character c = getCharacter(ch);
    6171            int s = str.size();
    6272            for (int i = 0; i < s; i++)
     
    7080    public static void StringLength (Expr string, Result length) throws RefalException {
    7181        try {
    72             length.assign(Symbol.newInt(Symbol.getString(string).size()));
     82            length.assign(Symbol.newInt(getString(string).size()));
    7383        } catch (ClassCastException _) {
    7484            throw new RefalException("String", "StringLength", "Invalid argument");
     
    7989    public static void StringRef (Expr string, Expr index, Result ch) throws RefalException {
    8090        try {
    81             ch.assign(Symbol.getString(string).get(Symbol.uintValue(index)));
     91            ch.assign(getString(string).get(Util.uintValue(index)));
    8292        } catch (NegativeValueException _) {
    8393            throw new RefalException("String", "StringRef", "Invalid argument");
     
    94104    public static void StringSet (Expr string, Expr index, Expr ch) throws RefalException {
    95105        try {
    96             Symbol.getString(string).set(Symbol.uintValue(index), Symbol.getCharacter(ch));
     106            getString(string).set(Util.uintValue(index), getCharacter(ch));
    97107        } catch (NegativeValueException _) {
    98108            throw new RefalException("String", "StringSet", "Invalid argument");
     
    109119    public static void StringReplace (Expr string, Expr source) throws RefalException {
    110120        try {
    111             org.refal.plus.objects.String str = Symbol.getString(string);
     121            org.refal.plus.objects.String str = getString(string);
    112122            str.clear();
    113123            str.init(source);
     
    120130    public static void Substring (Expr string, Expr index, Expr length, Result subString) throws RefalException {
    121131        try {
    122             int s = Symbol.uintValue(index);
    123             int e = s + Symbol.uintValue(length);
    124             Symbol.setToResult(Symbol.getString(string).subString(s, e), subString);
     132            int s = Util.uintValue(index);
     133            int e = s + Util.uintValue(length);
     134            Symbol.setObject(getString(string).subString(s, e), subString);
    125135        } catch (NegativeValueException _) {
    126136            throw new RefalException("String", "Substring", "Invalid argument");
     
    137147    public static void SubstringFill (Expr string, Expr index, Expr length, Expr ch) throws RefalException {
    138148        try {
    139             org.refal.plus.objects.String str = Symbol.getString(string);
    140             int s = Symbol.uintValue(index);
    141             int e = s + Symbol.uintValue(length);
    142             Character c = Symbol.getCharacter(ch);
     149            org.refal.plus.objects.String str = getString(string);
     150            int s = Util.uintValue(index);
     151            int e = s + Util.uintValue(length);
     152            Character c = getCharacter(ch);
    143153            for (int i = s; i < e; i++)
    144154                str.set(i, c);
  • to-imperative/trunk/java/java/refal/plus/Table.java

    r3707 r3725  
    1313    private Table () {}
    1414
     15    private static org.refal.plus.objects.Table getTable (Expr expr) throws ClassCastException {
     16        return (org.refal.plus.objects.Table) Symbol.getObject(expr);
     17    }
     18
    1519    @SuppressWarnings("all")
    1620    @RefalFormat("$func Table = s.table;")
    1721    public static void Table (Result table) {
    18         Symbol.setToResult(new org.refal.plus.objects.Table(), table);
     22        Symbol.setObject(new org.refal.plus.objects.Table(), table);
    1923    }
    2024
     
    2226    public static void Bind (Expr table, Expr key, Expr value) throws RefalException {
    2327        try {
    24             Symbol.getTable(table).put(key, value);
     28            getTable(table).put(key, value);
    2529        } catch (ClassCastException _) {
    2630            throw new RefalException("Table", "Bind", "Invalid argument");
     
    3135    public static void Unbind (Expr table, Expr key) throws RefalException {
    3236        try {
    33             Symbol.getTable(table).remove(key);
     37            getTable(table).remove(key);
    3438        } catch (ClassCastException _) {
    3539            throw new RefalException("Table", "Unbind", "Invalid argument");
     
    4044    public static boolean Lookup (Expr table, Expr key, Result value) throws RefalException {
    4145        try {
    42             Expr expr = Symbol.getTable(table).get(key);
     46            Expr expr = getTable(table).get(key);
    4347            if (expr == null)
    4448                return false;
     
    5357    public static boolean IsInTable (Expr table, Expr key) throws RefalException {
    5458        try {
    55             return Symbol.getTable(table).containsKey(key);
     59            return getTable(table).containsKey(key);
    5660        } catch (ClassCastException _) {
    5761            throw new RefalException("Table", "IsInTable", "Invalid argument");
     
    6266    public static void Domain (Expr table, Result keys) throws RefalException {
    6367        try {
    64             keys.assign(Symbol.getTable(table).getKeys());
     68            keys.assign(getTable(table).getKeys());
    6569        } catch (ClassCastException _) {
    6670            throw new RefalException("Table", "Domain", "Invalid argument");
     
    7276        assert table.length() == 1;
    7377        try {
    74             values.assign(Symbol.getTable(table).getValues());
     78            values.assign(getTable(table).getValues());
    7579        } catch (ClassCastException _) {
    7680            throw new RefalException("Table", "Values", "Invalid argument");
     
    8185    public static void Entries (Expr table, Result entries) throws RefalException {
    8286        try {
    83             entries.assign(Symbol.getTable(table).toExpr());
     87            entries.assign(getTable(table).toExpr());
    8488        } catch (ClassCastException _) {
    8589            throw new RefalException("Table", "Entries", "Invalid argument");
     
    9195        try {
    9296            org.refal.plus.objects.Table tab = new org.refal.plus.objects.Table();
    93             tab.putAll(Symbol.getTable(table));
    94             Symbol.setToResult(tab, tableCopy);
     97            tab.putAll(getTable(table));
     98            Symbol.setObject(tab, tableCopy);
    9599        } catch (ClassCastException _) {
    96100            throw new RefalException("Table", "TableCopy", "Invalid argument");
     
    101105    public static void ReplaceTable (Expr targetTable, Expr sourceTable) throws RefalException {
    102106        try {
    103             org.refal.plus.objects.Table tab = Symbol.getTable(targetTable);
     107            org.refal.plus.objects.Table tab = getTable(targetTable);
    104108            tab.clear();
    105             tab.putAll(Symbol.getTable(sourceTable));
     109            tab.putAll(getTable(sourceTable));
    106110        } catch (ClassCastException _) {
    107111            throw new RefalException("Table", "ReplaceTable", "Invalid argument");
     
    112116    public static void ClearTable (Expr table) throws RefalException {
    113117        try {
    114             Symbol.getTable(table).clear();
     118            getTable(table).clear();
    115119        } catch (ClassCastException _) {
    116120            throw new RefalException("Table", "ClearTable", "Invalid argument");
     
    121125    public static void TableSize (Expr table, Result size) throws RefalException {
    122126        try {
    123             size.assign(Symbol.newInt(Symbol.getTable(table).size()));
     127            size.assign(Symbol.newInt(getTable(table).size()));
    124128        } catch (ClassCastException _) {
    125129            throw new RefalException("Table", "TableSize", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/Vector.java

    r3719 r3725  
    88import org.refal.plus.Result;
    99import org.refal.plus.Symbol;
     10import org.refal.plus.Util;
    1011import org.refal.plus.Util.NegativeValueException;
    1112import org.refal.plus.Util.ValueOutOfBoundsException;
     
    1516    private Vector () {}
    1617
     18    private static org.refal.plus.objects.Vector getVector (Expr expr) throws ClassCastException {
     19        return (org.refal.plus.objects.Vector) Symbol.getObject(expr);
     20    }
     21
    1722    @SuppressWarnings("all")
    1823    @RefalFormat("$func Vector e.source = s.vector;")
     
    2126            org.refal.plus.objects.Vector vec = new org.refal.plus.objects.Vector();
    2227            vec.init(source);
    23             Symbol.setToResult(vec, vector);
     28            Symbol.setObject(vec, vector);
    2429        } catch (ClassCastException _) {
    2530            throw new RefalException("Vector", "Vector", "Invalid argument");
     
    3035    public static void VectorToExp (Expr vector, Result expr) throws RefalException {
    3136        try {
    32             expr.assign(Symbol.getVector(vector).toExpr());
     37            expr.assign(getVector(vector).toExpr());
    3338        } catch (ClassCastException _) {
    3439            throw new RefalException("Vector", "Vector", "Invalid argument");
     
    3944    public static void VectorInit (Expr vector, Expr lenght, Expr fill) throws RefalException {
    4045        try {
    41             org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
    42             int s = Symbol.uintValue(lenght);
     46            org.refal.plus.objects.Vector vec = getVector(vector);
     47            int s = Util.uintValue(lenght);
    4348            vec.clear();
    4449            for (int i = 0; i < s; i++)
     
    5661    public static void VectorFill (Expr vector, Expr fill) throws RefalException {
    5762        try {
    58             org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
     63            org.refal.plus.objects.Vector vec = getVector(vector);
    5964            int s = vec.size();
    6065            for (int i = 0; i < s; i++)
     
    6873    public static void VectorLength (Expr vector, Result length) throws RefalException {
    6974        try {
    70             length.assign(Symbol.newInt(Symbol.getVector(vector).size()));
     75            length.assign(Symbol.newInt(getVector(vector).size()));
    7176        } catch (ClassCastException _) {
    7277            throw new RefalException("Vector", "VectorLength", "Invalid argument");
     
    7782    public static void VectorRef (Expr vector, Expr index, Result expr) throws RefalException {
    7883        try {
    79             expr.assign(Symbol.getVector(vector).get(Symbol.uintValue(index)));
     84            expr.assign(getVector(vector).get(Util.uintValue(index)));
    8085        } catch (NegativeValueException _) {
    8186            throw new RefalException("Vector", "VectorRef", "Invalid argument");
     
    9297    public static void VectorSet (Expr vector, Expr index, Expr expr) throws RefalException {
    9398        try {
    94             Symbol.getVector(vector).set(Symbol.uintValue(index), expr);
     99            getVector(vector).set(Util.uintValue(index), expr);
    95100        } catch (NegativeValueException _) {
    96101            throw new RefalException("Vector", "VectorSet", "Invalid argument");
     
    107112    public static void VectorReplace (Expr vector, Expr source) throws RefalException {
    108113        try {
    109             org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
     114            org.refal.plus.objects.Vector vec = getVector(vector);
    110115            vec.clear();
    111116            vec.init(source);
     
    118123    public static void Subvector (Expr vector, Expr index, Expr length, Result subVector) throws RefalException {
    119124        try {
    120             int s = Symbol.uintValue(index);
    121             int e = s + Symbol.uintValue(length);
    122             Symbol.setToResult(Symbol.getVector(vector).subVector(s, e), subVector);
     125            int s = Util.uintValue(index);
     126            int e = s + Util.uintValue(length);
     127            Symbol.setObject(getVector(vector).subVector(s, e), subVector);
    123128        } catch (NegativeValueException _) {
    124129            throw new RefalException("Vector", "Subvector", "Invalid argument");
     
    135140    public static void SubvectorFill (Expr vector, Expr index, Expr length, Expr fill) throws RefalException {
    136141        try {
    137             org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
    138             int s = Symbol.uintValue(index);
    139             int e = s + Symbol.uintValue(length);
     142            org.refal.plus.objects.Vector vec = getVector(vector);
     143            int s = Util.uintValue(index);
     144            int e = s + Util.uintValue(length);
    140145            for (int i = s; i < e; i++)
    141146                vec.set(i, fill);
Note: See TracChangeset for help on using the changeset viewer.