Changeset 3719


Ignore:
Timestamp:
Apr 17, 2008, 3:30:36 PM (13 years ago)
Author:
yura
Message:
Location:
to-imperative/trunk/java/java
Files:
4 edited

Legend:

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

    r3718 r3719  
    3939
    4040    public static Comparable<?> newString (String name) {
    41         return new Reference<StringBuffer>(name, new StringBuffer());
    42         //return new Reference<org.refal.plus.objects.String>(name, new org.refal.plus.objects.String());
     41        return new Reference<org.refal.plus.objects.String>(name, new org.refal.plus.objects.String());
    4342    }
    4443
     
    9190    }
    9291
     92    public static org.refal.plus.objects.String getString (Expr expr) throws ClassCastException {
     93        assert expr.length() == 1;
     94        return (org.refal.plus.objects.String) ((Reference<?>) expr.at(0)).object;
     95    }
     96
    9397    public static Func getFunc (Expr expr) throws ClassCastException {
    9498        assert expr.length() == 1;
     
    103107        assert expr.length() == 1;
    104108        return (BigInteger) expr.at(0);
     109    }
     110
     111    public static Character getCharacter (Expr expr) throws ClassCastException {
     112        assert expr.length() == 1;
     113        return (Character) expr.at(0);
    105114    }
    106115
  • to-imperative/trunk/java/java/refal/plus/String.java

    r3423 r3719  
    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;
    169import org.refal.plus.Symbol;
    17 import org.refal.plus.Util;
     10import org.refal.plus.Util.NegativeValueException;
     11import org.refal.plus.Util.ValueOutOfBoundsException;
    1812
    1913public final class String {
     
    2115    private String () {}
    2216
    23     @SuppressWarnings("unchecked")
    24     private static void string (StringBuffer strbuf, Expr src) {
    25         for (Comparable<?> obj : src) {
    26             if (obj instanceof Character)
    27                 strbuf.append((Character) obj);
    28             else if (obj instanceof java.lang.String)
    29                 strbuf.append((java.lang.String) obj);
    30             else
    31                 strbuf.append(((Reference<StringBuffer>) obj).object);
    32         }
    33     }
    34 
    3517    @SuppressWarnings("all")
    36     @RefalFormat("$func String e.Source = s.String;")
    37     public static void String (Expr src, Result res) throws RefalException {
     18    @RefalFormat("$func String e.source = s.string;")
     19    public static void String (Expr source, Result string) throws RefalException {
    3820        try {
    39             Reference<StringBuffer> str = Symbol.newString();
    40             string(str.object, src);
    41             res.assign(str);
     21            org.refal.plus.objects.String str = new org.refal.plus.objects.String();
     22            str.init(source);
     23            Symbol.setToResult(str, string);
    4224        } catch (ClassCastException _) {
    4325            throw new RefalException("String", "String", "Invalid argument");
     
    4527    }
    4628
    47     @SuppressWarnings("unchecked")
    48     @RefalFormat("$func StringInit s.String s.Len s.Fill = ;")
    49     public static void StringInit (Expr str, Expr len, Expr fill) throws RefalException {
    50         assert str.length() == 1;
    51         assert len.length() == 1;
    52         assert fill.length() == 1;
     29    @RefalFormat("$func StringToExp s.string = e.expr;")
     30    public static void StringToExp (Expr string, Result expr) throws RefalException {
    5331        try {
    54             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    55             int s = Util.uintValue((BigInteger) len.at(0));
    56             char c = ((Character) fill.at(0)).charValue();
    57             strbuf.setLength(s);
     32            expr.assign(Symbol.getString(string).toExpr());
     33        } catch (ClassCastException _) {
     34            throw new RefalException("Vector", "Vector", "Invalid argument");
     35        }
     36    }
     37
     38    @RefalFormat("$func StringInit s.string s.lenght s.char = ;")
     39    public static void StringInit (Expr string, Expr lenght, Expr ch) throws RefalException {
     40        try {
     41            org.refal.plus.objects.String str = Symbol.getString(string);
     42            int s = Symbol.uintValue(lenght);
     43            Character c = Symbol.getCharacter(ch);
     44            str.clear();
    5845            for (int i = 0; i < s; i++)
    59                 strbuf.setCharAt(i, c);
    60         } catch (Util.NegativeValueException _) {
     46                str.add(c);
     47        } catch (NegativeValueException _) {
    6148            throw new RefalException("String", "StringInit", "Invalid argument");
    62         } catch (Util.ValueOutOfBoundsException _) {
     49        } catch (ValueOutOfBoundsException _) {
    6350            throw new RefalException("String", "StringInit", "Size limit exceeded");
    6451        } catch (ClassCastException _) {
     
    6754    }
    6855
    69     @SuppressWarnings("unchecked")
    70     @RefalFormat("$func StringFill s.String s.Fill = ;")
    71     public static void StringFill (Expr str, Expr fill) throws RefalException {
    72         assert str.length() == 1;
    73         assert fill.length() == 1;
     56    @RefalFormat("$func StringFill s.string s.char = ;")
     57    public static void StringFill (Expr string, Expr ch) throws RefalException {
    7458        try {
    75             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    76             int s = strbuf.length();
    77             char c = ((Character) fill.at(0)).charValue();
     59            org.refal.plus.objects.String str = Symbol.getString(string);
     60            Character c = Symbol.getCharacter(ch);
     61            int s = str.size();
    7862            for (int i = 0; i < s; i++)
    79                 strbuf.setCharAt(i, c);
     63                str.set(i, c);
    8064        } catch (ClassCastException _) {
    8165            throw new RefalException("String", "StringFill", "Invalid argument");
     
    8367    }
    8468
    85     @SuppressWarnings("unchecked")
    86     @RefalFormat("$func StringLength s.String = s.Len;")
    87     public static void StringLength (Expr str, Result res) throws RefalException {
    88         assert str.length() == 1;
     69    @RefalFormat("$func StringLength s.string = s.length;")
     70    public static void StringLength (Expr string, Result length) throws RefalException {
    8971        try {
    90             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    91             res.assign(BigInteger.valueOf(strbuf.length()));
     72            length.assign(Symbol.newInt(Symbol.getString(string).size()));
    9273        } catch (ClassCastException _) {
    9374            throw new RefalException("String", "StringLength", "Invalid argument");
     
    9576    }
    9677
    97     @SuppressWarnings("unchecked")
    98     @RefalFormat("$func StringRef s.String s.Index = s.Char;")
    99     public static void StringRef (Expr str, Expr idx, Result res) throws RefalException {
    100         assert str.length() == 1;
    101         assert idx.length() == 1;
     78    @RefalFormat("$func StringRef s.string s.index = s.char;")
     79    public static void StringRef (Expr string, Expr index, Result ch) throws RefalException {
    10280        try {
    103             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    104             char c = strbuf.charAt(Util.uintValue((BigInteger) idx.at(0)));
    105             res.assign(new Character(c));
    106         } catch (Util.NegativeValueException _) {
     81            ch.assign(Symbol.getString(string).get(Symbol.uintValue(index)));
     82        } catch (NegativeValueException _) {
    10783            throw new RefalException("String", "StringRef", "Invalid argument");
    108         } catch (Util.ValueOutOfBoundsException _) {
     84        } catch (ValueOutOfBoundsException _) {
    10985            throw new RefalException("String", "StringRef", "Index out of range");
    11086        } catch (IndexOutOfBoundsException _) {
     
    11591    }
    11692
    117     @SuppressWarnings("unchecked")
    118     @RefalFormat("$func StringSet s.String s.Index s.Char = ;")
    119     public static void StringSet (Expr str, Expr idx, Expr ch) throws RefalException {
    120         assert str.length() == 1;
    121         assert idx.length() == 1;
    122         assert ch.length() == 1;
     93    @RefalFormat("$func StringSet s.string s.index s.char = ;")
     94    public static void StringSet (Expr string, Expr index, Expr ch) throws RefalException {
    12395        try {
    124             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    125             char c = ((Character) ch.at(0)).charValue();
    126             strbuf.setCharAt(Util.uintValue((BigInteger) idx.at(0)), c);
    127         } catch (Util.NegativeValueException _) {
     96            Symbol.getString(string).set(Symbol.uintValue(index), Symbol.getCharacter(ch));
     97        } catch (NegativeValueException _) {
    12898            throw new RefalException("String", "StringSet", "Invalid argument");
    129         } catch (Util.ValueOutOfBoundsException _) {
     99        } catch (ValueOutOfBoundsException _) {
    130100            throw new RefalException("String", "StringSet", "Index out of range");
    131101        } catch (IndexOutOfBoundsException _) {
     
    136106    }
    137107
    138     @SuppressWarnings("unchecked")
    139     @RefalFormat("$func StringReplace s.String e.Source = ;")
    140     public static void StringReplace (Expr str, Expr src) throws RefalException {
    141         assert str.length() == 1;
     108    @RefalFormat("$func StringReplace s.string e.source = ;")
     109    public static void StringReplace (Expr string, Expr source) throws RefalException {
    142110        try {
    143             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    144             strbuf.setLength(0);
    145             string(strbuf, src);
     111            org.refal.plus.objects.String str = Symbol.getString(string);
     112            str.clear();
     113            str.init(source);
    146114        } catch (ClassCastException _) {
    147115            throw new RefalException("String", "StringReplace", "Invalid argument");
     
    149117    }
    150118
    151     @SuppressWarnings("unchecked")
    152     @RefalFormat("$func Substring s.String s.Index s.Len = s.NewString;")
    153     public static void Substring (Expr str, Expr idx, Expr len, Result res) throws RefalException {
    154         assert str.length() == 1;
    155         assert idx.length() == 1;
    156         assert len.length() == 1;
     119    @RefalFormat("$func Substring s.string s.index s.length = s.substring;")
     120    public static void Substring (Expr string, Expr index, Expr length, Result subString) throws RefalException {
    157121        try {
    158             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    159             int s = Util.uintValue((BigInteger) idx.at(0));
    160             int e = s + Util.uintValue((BigInteger) len.at(0));
    161             Reference<StringBuffer> newstr = Symbol.newString();
    162             newstr.object.append(strbuf.substring(s, e));
    163             res.assign(newstr);
    164         } catch (Util.NegativeValueException _) {
     122            int s = Symbol.uintValue(index);
     123            int e = s + Symbol.uintValue(length);
     124            Symbol.setToResult(Symbol.getString(string).subString(s, e), subString);
     125        } catch (NegativeValueException _) {
    165126            throw new RefalException("String", "Substring", "Invalid argument");
    166         } catch (Util.ValueOutOfBoundsException _) {
     127        } catch (ValueOutOfBoundsException _) {
    167128            throw new RefalException("String", "Substring", "Index out of range");
    168129        } catch (IndexOutOfBoundsException _) {
     
    173134    }
    174135
    175     @SuppressWarnings("unchecked")
    176     @RefalFormat("$func SubstringFill s.String s.Index s.Len s.Fill = ;")
    177     public static void SubstringFill (Expr str, Expr idx, Expr len, Expr fill) throws RefalException {
    178         assert str.length() == 1;
    179         assert idx.length() == 1;
    180         assert len.length() == 1;
    181         assert fill.length() == 1;
     136    @RefalFormat("$func SubstringFill s.string s.index s.length s.char = ;")
     137    public static void SubstringFill (Expr string, Expr index, Expr length, Expr ch) throws RefalException {
    182138        try {
    183             StringBuffer strbuf = ((Reference<StringBuffer>) str.at(0)).object;
    184             int s = Util.uintValue((BigInteger) idx.at(0));
    185             int e = s + Util.uintValue((BigInteger) len.at(0));
    186             char c = ((Character) fill.at(0)).charValue();
     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);
    187143            for (int i = s; i < e; i++)
    188                 strbuf.setCharAt(i, c);
    189         } catch (Util.NegativeValueException _) {
     144                str.set(i, c);
     145        } catch (NegativeValueException _) {
    190146            throw new RefalException("String", "SubvectorFill", "Invalid argument");
    191         } catch (Util.ValueOutOfBoundsException _) {
     147        } catch (ValueOutOfBoundsException _) {
    192148            throw new RefalException("String", "SubvectorFill", "Index out of range");
    193149        } catch (IndexOutOfBoundsException _) {
  • to-imperative/trunk/java/java/refal/plus/Vector.java

    r3707 r3719  
    88import org.refal.plus.Result;
    99import org.refal.plus.Symbol;
    10 import org.refal.plus.Util;
    1110import org.refal.plus.Util.NegativeValueException;
    1211import org.refal.plus.Util.ValueOutOfBoundsException;
     
    3736    }
    3837
    39     @RefalFormat("$func VectorInit s.vector s.len e.fill = ;")
    40     public static void VectorInit (Expr vector, Expr len, Expr fill) throws RefalException {
     38    @RefalFormat("$func VectorInit s.vector s.lenght e.fill = ;")
     39    public static void VectorInit (Expr vector, Expr lenght, Expr fill) throws RefalException {
    4140        try {
    4241            org.refal.plus.objects.Vector vec = Symbol.getVector(vector);
     42            int s = Symbol.uintValue(lenght);
    4343            vec.clear();
    44             int s = Symbol.uintValue(len);
    4544            for (int i = 0; i < s; i++)
    4645                vec.add(fill);
     
    122121            int e = s + Symbol.uintValue(length);
    123122            Symbol.setToResult(Symbol.getVector(vector).subVector(s, e), subVector);
    124         } catch (Util.NegativeValueException _) {
     123        } catch (NegativeValueException _) {
    125124            throw new RefalException("Vector", "Subvector", "Invalid argument");
    126         } catch (Util.ValueOutOfBoundsException _) {
     125        } catch (ValueOutOfBoundsException _) {
    127126            throw new RefalException("Vector", "Subvector", "Index out of range");
    128127        } catch (IndexOutOfBoundsException _) {
     
    141140            for (int i = s; i < e; i++)
    142141                vec.set(i, fill);
    143         } catch (Util.NegativeValueException _) {
     142        } catch (NegativeValueException _) {
    144143            throw new RefalException("Vector", "SubvectorFill", "Invalid argument");
    145         } catch (Util.ValueOutOfBoundsException _) {
     144        } catch (ValueOutOfBoundsException _) {
    146145            throw new RefalException("Vector", "SubvectorFill", "Index out of range");
    147146        } catch (IndexOutOfBoundsException _) {
  • to-imperative/trunk/java/java/refal/plus/internal/Convert.java

    r3682 r3719  
    1 /*
    2  * $Id$
    3  *
    4  * vim: set syntax=java expandtab shiftwidth=4 tabstop=4:
    5  */
     1// $Id$
    62
    73package refal.plus.internal;
    84
    9 import java.lang.String;
    105import java.math.BigInteger;
    116
Note: See TracChangeset for help on using the changeset viewer.