Changeset 3691


Ignore:
Timestamp:
Apr 12, 2008, 6:40:41 PM (13 years ago)
Author:
yura
Message:
  • Refactoring Table and Vector.
Location:
to-imperative/trunk/java/java
Files:
6 edited

Legend:

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

    r3690 r3691  
    1 /*
    2  * $Id$
    3  *
    4  * vim: set syntax=java expandtab shiftwidth=4 tabstop=4:
    5  */
     1// $Id$
    62
    73package org.refal.plus;
    84
    95import java.math.BigInteger;
    10 import java.util.Map;
    116
    127public final class Symbol {
     
    3227    }
    3328
    34     public static Reference<StringBuffer> newString () {
    35         return new Reference<StringBuffer>(new StringBuffer());
    36     }
    37 
    3829    public static Comparable<?> newString (String name) {
    3930        return new Reference<StringBuffer>(name, new StringBuffer());
    4031    }
    4132
    42     public static Reference<Map<Expr, Expr>> newTable () {
    43         return new Reference<Map<Expr, Expr>>(new Table());
    44     }
    45 
    4633    public static Comparable<?> newTable (String name) {
    47         return new Reference<Map<Expr, Expr>>(name, new Table());
     34        return new Reference<Table>(name, new Table());
    4835    }
    4936
     
    5138        return new Reference<Vector>(name, new Vector());
    5239    }
     40
     41
     42    public static Reference<StringBuffer> newString () {
     43        return new Reference<StringBuffer>(new StringBuffer());
     44    }
     45
     46   
     47    public static Table getTable (Expr expr) throws ClassCastException {
     48        assert expr.length() == 1;
     49        return (Table) ((Reference<?>) expr.at(0)).object;
     50    }
     51
     52    public static Vector getVector (Expr expr) throws ClassCastException {
     53        assert expr.length() == 1;
     54        return (Vector) ((Reference<?>) expr.at(0)).object;
     55    }
     56
     57    public static <T> void setToResult (T object, Result res) {
     58        res.assign(new Reference<T>(object));
     59    }
    5360}
  • to-imperative/trunk/java/java/org/refal/plus/Table.java

    r3689 r3691  
     1// $Id: Symbol.java 3690 2008-04-12 12:23:44Z yura $
     2
    13package org.refal.plus;
    24
     
    3234        return concat.yield();
    3335    }
     36   
     37    public Expr getKeys () {
     38        Expr.Concatenator concat = Expr.getConcatenator(size());
     39        for (Expr expr : keySet())
     40            concat.toRight((Comparable<?>) expr);
     41        return concat.yield();
     42    }
     43
     44    public Expr getValues () {
     45        Expr.Concatenator concat = Expr.getConcatenator(size());
     46        for (Expr expr : values())
     47            concat.toRight((Comparable<?>) expr);
     48        return concat.yield();
     49    }
    3450
    3551    @Override
  • to-imperative/trunk/java/java/org/refal/plus/Util.java

    r3419 r3691  
    1 /*
    2  * $Id$
    3  *
    4  * vim: set syntax=java expandtab shiftwidth=4 tabstop=4:
    5  */
     1// $Id$
    62
    73package org.refal.plus;
     
    3834    }
    3935
     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
    4046    private static final BigInteger minLong = BigInteger.valueOf(Long.MIN_VALUE);
    4147    private static final BigInteger maxLong = BigInteger.valueOf(Long.MAX_VALUE);
  • to-imperative/trunk/java/java/org/refal/plus/Vector.java

    r3690 r3691  
     1// $Id$
     2
    13package org.refal.plus;
    24
     
    79   
    810    public void init (Expr expr) throws ClassCastException {
    9         this.clear();
    1011        for (Comparable<?> term : expr)
    1112            if (term instanceof Expr)
  • to-imperative/trunk/java/java/refal/plus/Table.java

    r3423 r3691  
    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;
    10 import java.util.Collection;
    11 import java.util.Map;
    12 import java.util.Set;
    134
    145import org.refal.plus.Expr;
    156import org.refal.plus.RefalException;
    167import org.refal.plus.RefalFormat;
    17 import org.refal.plus.Reference;
    188import org.refal.plus.Result;
    199import org.refal.plus.Symbol;
     10import org.refal.plus.Util;
    2011
    2112public final class Table {
     
    2617    @RefalFormat("$func Table = s.Tab;")
    2718    public static void Table (Result res) {
    28         res.assign(Symbol.newTable());
     19        Symbol.setToResult(new org.refal.plus.Table(), res);
    2920    }
    3021
     
    3223    @RefalFormat("$func Bind s.Tab (e.Key) (e.Val) = ;")
    3324    public static void Bind (Expr tab, Expr key, Expr val) throws RefalException {
    34         assert tab.length() == 1;
    3525        try {
    36             ((Reference<Map<Expr, Expr>>) tab.at(0)).object.put(key, val);
     26            Symbol.getTable(tab).put(key, val);
    3727        } catch (ClassCastException _) {
    3828            throw new RefalException("Table", "Bind", "Invalid argument");
     
    4333    @RefalFormat("$func Unbind s.Tab e.Key = ;")
    4434    public static void Unbind (Expr tab, Expr key) throws RefalException {
    45         assert tab.length() == 1;
    4635        try {
    47             ((Reference<Map<Expr, Expr>>) tab.at(0)).object.remove(key);
     36            Symbol.getTable(tab).remove(key);
    4837        } catch (ClassCastException _) {
    4938            throw new RefalException("Table", "Unbind", "Invalid argument");
     
    5443    @RefalFormat("$func? Lookup s.Tab e.Key = e.Val;")
    5544    public static boolean Lookup (Expr tab, Expr key, Result val) throws RefalException {
    56         assert tab.length() == 1;
    5745        try {
    58             Expr expr = ((Reference<Map<Expr, Expr>>) tab.at(0)).object.get(key);
     46            Expr expr = Symbol.getTable(tab).get(key);
    5947            if (expr == null)
    6048                return false;
     
    6957    @RefalFormat("$func? IsInTable s.Tab e.Key = ;")
    7058    public static boolean IsInTable (Expr tab, Expr key) throws RefalException {
    71         assert tab.length() == 1;
    7259        try {
    73             return ((Reference<Map<Expr, Expr>>) tab.at(0)).object.containsKey(key);
     60            return Symbol.getTable(tab).containsKey(key);
    7461        } catch (ClassCastException _) {
    7562            throw new RefalException("Table", "IsInTable", "Invalid argument");
     
    8067    @RefalFormat("$func Domain s.Tab = e.KeyList;")
    8168    public static void Domain (Expr tab, Result res) throws RefalException {
    82         assert tab.length() == 1;
    8369        try {
    84             Set<Expr> c = ((Reference<Map<Expr, Expr>>) tab.at(0)).object.keySet();
    85             Expr.Concatenator concat = Expr.getConcatenator(c.size());
    86             for (Expr expr : c)
    87                 concat.toRight((Comparable<?>) expr);
    88             res.assign(concat.yield());
     70            res.assign(Symbol.getTable(tab).getKeys());
    8971        } catch (ClassCastException _) {
    9072            throw new RefalException("Table", "Domain", "Invalid argument");
     
    9779        assert tab.length() == 1;
    9880        try {
    99             Collection<Expr> c = ((Reference<Map<Expr, Expr>>) tab.at(0)).object.values();
    100             Expr.Concatenator concat = Expr.getConcatenator(c.size());
    101             for (Expr expr : c)
    102                 concat.toRight((Comparable<?>) expr);
    103             res.assign(concat.yield());
     81            res.assign(Symbol.getTable(tab).getValues());
    10482        } catch (ClassCastException _) {
    10583            throw new RefalException("Table", "Values", "Invalid argument");
     
    11088    @RefalFormat("$func Entries s.Tab = e.KeyValuePairs;")
    11189    public static void Entries (Expr tab, Result res) throws RefalException {
    112         assert tab.length() == 1;
    11390        try {
    114             Map<Expr, Expr> map = ((Reference<Map<Expr, Expr>>) tab.at(0)).object;
    115             Expr.Concatenator concat = Expr.getConcatenator(map.size());
    116             for (Map.Entry<Expr, Expr> pair : map.entrySet())
    117                 concat.toRight((Comparable<?>) Expr.concat((Comparable<?>) pair.getKey(), (Comparable<?>) pair
    118                         .getValue()));
    119             res.assign(concat.yield());
     91            res.assign(Symbol.getTable(tab).toExpr());
    12092        } catch (ClassCastException _) {
    12193            throw new RefalException("Table", "Entries", "Invalid argument");
     
    12698    @RefalFormat("$func TableCopy s.Tab = s.TabCopy;")
    12799    public static void TableCopy (Expr tab, Result res) throws RefalException {
    128         assert tab.length() == 1;
    129100        try {
    130             Reference<Map<Expr, Expr>> map = Symbol.newTable();
    131             map.object.putAll(((Reference<Map<Expr, Expr>>) tab.at(0)).object);
    132             res.assign(map);
     101            org.refal.plus.Table table = new org.refal.plus.Table();
     102            table.putAll(Symbol.getTable(tab));
     103            Symbol.setToResult(table, res);
    133104        } catch (ClassCastException _) {
    134105            throw new RefalException("Table", "TableCopy", "Invalid argument");
     
    139110    @RefalFormat("$func ReplaceTable s.TargetTab s.SourceTab = ;")
    140111    public static void ReplaceTable (Expr target, Expr source) throws RefalException {
    141         assert target.length() == 1;
    142         assert source.length() == 1;
    143112        try {
    144             Map<Expr, Expr> map = ((Reference<Map<Expr, Expr>>) target.at(0)).object;
    145             map.clear();
    146             map.putAll(((Reference<Map<Expr, Expr>>) source.at(0)).object);
     113            org.refal.plus.Table table = Symbol.getTable(target);
     114            table.clear();
     115            table.putAll(Symbol.getTable(source));
    147116        } catch (ClassCastException _) {
    148117            throw new RefalException("Table", "ReplaceTable", "Invalid argument");
     
    153122    @RefalFormat("$func ClearTable s.Tab = ;")
    154123    public static void ClearTable (Expr tab) throws RefalException {
    155         assert tab.length() == 1;
    156124        try {
    157             ((Reference<Map<Expr, Expr>>) tab.at(0)).object.clear();
     125            Symbol.getTable(tab).clear();
    158126        } catch (ClassCastException _) {
    159127            throw new RefalException("Table", "ClearTable", "Invalid argument");
     
    164132    @RefalFormat("$func TableSize s.Tab = s.Size;")
    165133    public static void TableSize (Expr tab, Result res) throws RefalException {
    166         assert tab.length() == 1;
    167134        try {
    168             res.assign(BigInteger.valueOf(((Reference<Map<Expr, Expr>>) tab.at(0)).object.size()));
     135            res.assign(Util.bigIntegerValue(Symbol.getTable(tab).size()));
    169136        } catch (ClassCastException _) {
    170137            throw new RefalException("Table", "TableSize", "Invalid argument");
  • to-imperative/trunk/java/java/refal/plus/Vector.java

    r3690 r3691  
    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;
    126import org.refal.plus.RefalException;
    137import org.refal.plus.RefalFormat;
    14 import org.refal.plus.Reference;
    158import org.refal.plus.Result;
     9import org.refal.plus.Symbol;
    1610import org.refal.plus.Util;
    1711
     
    1913    /** Don't let anyone instantiate this class */
    2014    private Vector () {}
    21 
     15   
    2216    @SuppressWarnings("all")
    2317    @RefalFormat("$func Vector e.Source = s.Vector;")
    2418    public static void Vector (Expr src, Result res) throws RefalException {
    2519        try {
    26             org.refal.plus.Vector list = new org.refal.plus.Vector();
    27             list.init(src);
    28             res.assign(new Reference<org.refal.plus.Vector>(list));
     20            org.refal.plus.Vector vector = new org.refal.plus.Vector();
     21            vector.init(src);
     22            Symbol.setToResult(vector, res);
    2923        } catch (ClassCastException _) {
    3024            throw new RefalException("Vector", "Vector", "Invalid argument");
     
    3226    }
    3327
    34     @SuppressWarnings("unchecked")
    3528    @RefalFormat("$func VectorToExp s.Vector = e.Exp;")
    3629    public static void VectorToExp (Expr vec, Result res) throws RefalException {
    37         assert vec.length() == 1;
    3830        try {
    39             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    40             res.assign(list.toExpr());
     31            res.assign(Symbol.getVector(vec).toExpr());
    4132        } catch (ClassCastException _) {
    4233            throw new RefalException("Vector", "Vector", "Invalid argument");
     
    4435    }
    4536
    46     @SuppressWarnings("unchecked")
    4737    @RefalFormat("$func VectorInit s.Vector s.Len e.Fill = ;")
    4838    public static void VectorInit (Expr vec, Expr len, Expr fill) throws RefalException {
    49         assert vec.length() == 1;
    50         assert len.length() == 1;
    5139        try {
    52             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    53             int s = Util.uintValue((BigInteger) len.at(0));
    54             list.clear();
     40            org.refal.plus.Vector vector = Symbol.getVector(vec);
     41            vector.clear();
     42            int s = Util.uintValue(len);
    5543            for (int i = 0; i < s; i++)
    56                 list.add(fill);
     44                vector.add(fill);
    5745        } catch (Util.NegativeValueException _) {
    5846            throw new RefalException("Vector", "VectorInit", "Invalid argument");
     
    6452    }
    6553
    66     @SuppressWarnings("unchecked")
    6754    @RefalFormat("$func VectorFill s.Vector e.Fill = ;")
    6855    public static void VectorFill (Expr vec, Expr fill) throws RefalException {
    69         assert vec.length() == 1;
    7056        try {
    71             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    72             int s = list.size();
     57            org.refal.plus.Vector vector = Symbol.getVector(vec);
     58            int s = vector.size();
    7359            for (int i = 0; i < s; i++)
    74                 list.set(i, fill);
     60                vector.set(i, fill);
    7561        } catch (ClassCastException _) {
    7662            throw new RefalException("Vector", "VectorFill", "Invalid argument");
     
    7864    }
    7965
    80     @SuppressWarnings("unchecked")
    8166    @RefalFormat("$func VectorLength s.Vector = s.Len;")
    8267    public static void VectorLength (Expr vec, Result res) throws RefalException {
    83         assert vec.length() == 1;
    8468        try {
    85             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    86             res.assign(BigInteger.valueOf(list.size()));
     69            res.assign(Util.bigIntegerValue(Symbol.getVector(vec).size()));
    8770        } catch (ClassCastException _) {
    8871            throw new RefalException("Vector", "VectorLength", "Invalid argument");
     
    9073    }
    9174
    92     @SuppressWarnings("unchecked")
    9375    @RefalFormat("$func VectorRef s.Vector s.Index = e.Exp;")
    9476    public static void VectorRef (Expr vec, Expr idx, Result res) throws RefalException {
    95         assert vec.length() == 1;
    96         assert idx.length() == 1;
    9777        try {
    98             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    99             res.assign(list.get(Util.uintValue((BigInteger) idx.at(0))));
     78            res.assign(Symbol.getVector(vec).get(Util.uintValue(idx)));
    10079        } catch (Util.NegativeValueException _) {
    10180            throw new RefalException("Vector", "VectorRef", "Invalid argument");
     
    10988    }
    11089
    111     @SuppressWarnings("unchecked")
    11290    @RefalFormat("$func VectorSet s.Vector s.Index e.Exp = ;")
    11391    public static void VectorSet (Expr vec, Expr idx, Expr e) throws RefalException {
    114         assert vec.length() == 1;
    115         assert idx.length() == 1;
    11692        try {
    117             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    118             list.set(Util.uintValue((BigInteger) idx.at(0)), e);
     93            Symbol.getVector(vec).set(Util.uintValue(idx), e);
    11994        } catch (Util.NegativeValueException _) {
    12095            throw new RefalException("Vector", "VectorSet", "Invalid argument");
     
    128103    }
    129104
    130     @SuppressWarnings("unchecked")
    131105    @RefalFormat("$func VectorReplace s.Vector e.Source = ;")
    132106    public static void VectorReplace (Expr vec, Expr src) throws RefalException {
    133         assert vec.length() == 1;
    134107        try {
    135             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    136             list.clear();
    137             list.init(src);
     108            org.refal.plus.Vector vector = Symbol.getVector(vec);
     109            vector.clear();
     110            vector.init(src);
    138111        } catch (ClassCastException _) {
    139112            throw new RefalException("Vector", "VectorReplace", "Invalid argument");
     
    141114    }
    142115
    143     @SuppressWarnings("unchecked")
    144116    @RefalFormat("$func Subvector s.Vector s.Index s.Len = s.NewVector;")
    145117    public static void Subvector (Expr vec, Expr idx, Expr len, Result res) throws RefalException {
    146         assert vec.length() == 1;
    147         assert idx.length() == 1;
    148         assert len.length() == 1;
    149118        try {
    150             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    151             int s = Util.uintValue((BigInteger) idx.at(0));
    152             int e = s + Util.uintValue((BigInteger) len.at(0));
    153             res.assign(new Reference<org.refal.plus.Vector>(list.subVector(s, e)));
     119            int s = Util.uintValue(idx);
     120            int e = s + Util.uintValue(len);
     121            Symbol.setToResult(Symbol.getVector(vec).subVector(s, e), res);
    154122        } catch (Util.NegativeValueException _) {
    155123            throw new RefalException("Vector", "Subvector", "Invalid argument");
     
    163131    }
    164132
    165     @SuppressWarnings("unchecked")
    166133    @RefalFormat("$func SubvectorFill s.Vector s.Index s.Len e.Fill = ;")
    167134    public static void SubvectorFill (Expr vec, Expr idx, Expr len, Expr fill) throws RefalException {
    168         assert vec.length() == 1;
    169         assert idx.length() == 1;
    170         assert len.length() == 1;
    171135        try {
    172             org.refal.plus.Vector list = ((Reference<org.refal.plus.Vector>) vec.at(0)).object;
    173             int s = Util.uintValue((BigInteger) idx.at(0));
    174             int e = s + Util.uintValue((BigInteger) len.at(0));
     136            org.refal.plus.Vector vector = Symbol.getVector(vec);
     137            int s = Util.uintValue(idx);
     138            int e = s + Util.uintValue(len);
    175139            for (int i = s; i < e; i++)
    176                 list.set(i, fill);
     140                vector.set(i, fill);
    177141        } catch (Util.NegativeValueException _) {
    178142            throw new RefalException("Vector", "SubvectorFill", "Invalid argument");
Note: See TracChangeset for help on using the changeset viewer.