Changeset 1796


Ignore:
Timestamp:
Nov 26, 2005, 10:24:13 AM (15 years ago)
Author:
orlov
Message:
  • Prelimenary version of Num interface and its Int32 implementation.
  • Polymorphic version of Access library.
Location:
to-imperative/trunk/java/org/refal/plus
Files:
3 added
1 edited

Legend:

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

    r1783 r1796  
    1 package org.refal.j;
     1/*
     2 * $Id$
     3 */
    24
    3 import java.lang.*;
    4 import java.math.BigInteger;
     5package org.refal.plus;
    56
    6 /**
    7  * @author alex
    8  *
    9  * Refal java runtime library: 23.02.2005
    10  */
    117public class Access
    128{
    13    
    14     /** L -- deletes from @param b first @param a terms
    15      * @param a
    16      * @param b
    17      * @param c
    18      * @return boolean
    19      */
    20     public static boolean L (Expr a, Expr b, Expr c)
     9    private Num num;
     10
     11    public Access (Num n)
    2112    {
    22         int index = 0;
     13        num = n;
     14    }
     15
     16    private String lib_name ()
     17    {
     18        return "Access(" + num.getClass().getName() + ")";
     19    }
     20
     21    public boolean L (Expr s_left, Expr e_exp, Expr t_subexp)
     22        throws RefalException
     23    {
     24        // FIXME: insert here assertion s_left.getLen() == 1
    2325        try {
    24             index = Expr.Expr_to_Int (a);
     26            int left = num.intValue(s_left.at(0), 0, Integer.MAX_VALUE);
     27            if (e_exp.getLen() == 0 || left > e_exp.getLen() - 1)
     28                return false;
     29            t_subexp.assign(new Expr(e_exp, left, 1));
     30            return true;
    2531        }
    2632        catch (ClassCastException e) {
    27             Error.print ("L");
     33            throw new RefalException(lib_name(), "L", "Invalid argument");
    2834        }
    29         if (index == b.get_len () || b.get_len () == 0)
     35        catch (ValueOutOfBoundsException e) {
    3036            return false;
    31         if (index < 0 || index > b.get_len ())
    32             Error.print ("L");
    33         c.assign (b.elementAt (index));
    34         return true;
     37        }
    3538    }
    3639
    37     /** Left -- deletes from @param c first @param a terms, then takes first @param b terms from the rest
    38      * @param a
    39      * @param b
    40      * @param c
    41      * @param d
    42      * @return boolean
    43      */
    44     public static boolean Left (Expr a, Expr b, Expr c, Expr d)
     40    public boolean R (Expr s_right, Expr e_exp, Expr t_subexp)
     41        throws RefalException
    4542    {
    46         int index1 = 0;
    47         int index2 = 0;
     43        // FIXME: insert here assertion s_right.getLen() == 1
    4844        try {
    49             index1 = Expr.Expr_to_Int (a);
    50             index2 = Expr.Expr_to_Int (b);
     45            int right = num.intValue(s_right.at(0), 0, Integer.MAX_VALUE);
     46            if (e_exp.getLen() == 0 || right > e_exp.getLen() - 1)
     47                return false;
     48            t_subexp.assign(new Expr(e_exp, e_exp.getLen() - right - 1, 1));
     49            return true;
    5150        }
    5251        catch (ClassCastException e) {
    53             Error.print ("Left");
     52            throw new RefalException(lib_name(), "R", "Invalid argument");
    5453        }
    55         if (index1 < 0 || index2 < 0)
    56             Error.print ("Left");
    57         if (index2+index1 > c.get_len ())
     54        catch (ValueOutOfBoundsException e) {
    5855            return false;
    59         if (c.get_len () == 0) return false;
    60         Expr.assign (Expr.Subexpr (c, index1, index2), d);
    61         return true;
     56        }
    6257    }
    6358
    64     /** Length -- defines the length of the expression
    65      * @param a
    66      * @param b
    67      */
    68     public static void Length (Expr a, Expr b)
     59    public boolean Left (Expr s_left, Expr s_len, Expr e_exp, Expr e_subexp)
     60        throws RefalException
    6961    {
    70         b.assign (new Integer (a.get_len () + ""));       
     62        // FIXME: insert here assertion s_left.getLen() == 1
     63        // FIXME: insert here assertion s_len.getLen() == 1
     64        try {
     65            int len  = num.intValue(s_len .at(0), 0, Integer.MAX_VALUE);
     66            int left = num.intValue(s_left.at(0), 0, Integer.MAX_VALUE);
     67            if (e_exp.getLen() < len || left > e_exp.getLen() - len)
     68                return false;
     69            e_subexp.assign(new Expr(e_exp, left, len));
     70            return true;
     71        }
     72        catch (ClassCastException e) {
     73            throw new RefalException(lib_name(), "Left", "Invalid argument");
     74        }
     75        catch (ValueOutOfBoundsException e) {
     76            return false;
     77        }
    7178    }
    7279
    73     /** Middle -- deletes from @param c first @param a terms and last @param b terms
    74      * @param a
    75      * @param b
    76      * @param c
    77      * @param d
    78      * @return boolean
    79      */
    80     public static boolean Middle (Expr a, Expr b, Expr c, Expr d)
     80    public boolean Right (Expr s_right, Expr s_len, Expr e_exp, Expr e_subexp)
     81        throws RefalException
    8182    {
    82         int index1 = 0;
    83         int index2 = 0;
     83        // FIXME: insert here assertion s_right.getLen() == 1
     84        // FIXME: insert here assertion s_len.getLen() == 1
    8485        try {
    85             index1 = Expr.Expr_to_Int (a);
    86             index2 = Expr.Expr_to_Int (b);
     86            int len   = num.intValue(s_len  .at(0), 0, Integer.MAX_VALUE);
     87            int right = num.intValue(s_right.at(0), 0, Integer.MAX_VALUE);
     88            if (e_exp.getLen() < len || right > e_exp.getLen() - len)
     89                return false;
     90            e_subexp.assign(new Expr(e_exp, e_exp.getLen() - right - len, len));
     91            return true;
    8792        }
    8893        catch (ClassCastException e) {
    89             Error.print ("Middle");
     94            throw new RefalException(lib_name(), "Right", "Invalid argument");
    9095        }
    91         if (index1 < 0 || index2 < 0)
    92             Error.print ("Middle");
    93         if (index2+index1 > c.get_len ())
     96        catch (ValueOutOfBoundsException e) {
    9497            return false;
    95         Expr.assign (c, d);
    96         d.setIndex (d.getIndex() + index1);
    97         if (index2 == 0)
    98             d.setLength (d.getLength () - index1);
    99         else   
    100             d.setLength ((d.getLength () - index2) - d.getIndex ());
    101         if (d.getLength () < 0 || d.getIndex () < 0)
    102             Error.print ("Invalid Argument! Middle");
    103         return true;
     98        }
    10499    }
    105100
    106     /** R -- deletes from @param b last @param a terms
    107      * @param a
    108      * @param b
    109      * @param c
    110      * @return boolean
    111      */
    112     public static boolean R (Expr a, Expr b, Expr c)
     101    public boolean Middle (Expr s_left, Expr s_right, Expr e_exp, Expr e_subexp)
     102        throws RefalException
    113103    {
    114         int index = 0;
     104        // FIXME: insert here assertion s_left.getLen() == 1
     105        // FIXME: insert here assertion s_right.getLen() == 1
    115106        try {
    116             index = Expr.Expr_to_Int (a);
     107            int left  = num.intValue(s_left .at(0), 0, Integer.MAX_VALUE);
     108            int right = num.intValue(s_right.at(0), 0, Integer.MAX_VALUE);
     109            if (e_exp.getLen() < right || left > e_exp.getLen() - right)
     110                return false;
     111            e_subexp.assign(new Expr(e_exp, left, e_exp.getLen() - right - left));
     112            return true;
    117113        }
    118114        catch (ClassCastException e) {
    119             Error.print ("R");
     115            throw new RefalException(lib_name(), "Middle", "Invalid argument");
    120116        }
    121         if (index == b.get_len () || b.get_len () == 0)
     117        catch (ValueOutOfBoundsException e) {
    122118            return false;
    123         if (index < 0 || index > b.get_len ())
    124             Error.print ("R");
    125         c.assign (b.elementAt (b.get_len () - 1 - index));
    126         return true;
     119        }
    127120    }
    128121
    129     /** Right -- deletes from @param c last @param a terms, then takes @param b terms from the rest
    130      * @param a
    131      * @param b
    132      * @param c
    133      * @param d
    134      * @return boolean
    135      */
    136     public static boolean Right (Expr a, Expr b, Expr c, Expr d)
     122    public void Length (Expr e_exp, Expr s_len)
    137123    {
    138         int index1 = 0;
    139         int index2 = 0;
    140         try {
    141             index1 = Expr.Expr_to_Int (a);
    142             index2 = Expr.Expr_to_Int (b);
    143         }
    144         catch (ClassCastException e) {
    145             Error.print ("Right");
    146         }
    147         if (index1 < 0 || index2 < 0)
    148             Error.print ("Right");
    149         if (index2 > c.get_len () - index1)
    150             return false;
    151         if (c.get_len () == 0) return false;
    152         Expr.assign (c, d);
    153         d.setIndex (d.getLength () - index1 - index2 + 1);
    154         d.setLength (index2);
    155         return true;
     124        s_len.assign(new Expr(num.create(e_exp.getLen())));       
    156125    }
    157126}
Note: See TracChangeset for help on using the changeset viewer.