Changeset 3596


Ignore:
Timestamp:
09/08/03 01:35:30 (19 years ago)
Author:
piso
Message:

%STRUCTURE-REF-0, %STRUCTURE-REF-1, %STRUCTURE-REF-2
%STRUCTURE-SET-0, %STRUCTURE-SET-1, %STRUCTURE-SET-2

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/StructureObject.java

    r3593 r3596  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: StructureObject.java,v 1.7 2003-09-07 16:41:53 piso Exp $
     5 * $Id: StructureObject.java,v 1.8 2003-09-08 01:35:30 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    5353            return T;
    5454        return super.typep(typeSpecifier);
    55     }
    56 
    57     public LispObject get(int index) throws LispError
    58     {
    59         try {
    60             return slots[index];
    61         }
    62         catch (ArrayIndexOutOfBoundsException e) {
    63             getStandardOutput().printStackTrace(e);
    64             throw new LispError("internal error");
    65         }
    66     }
    67 
    68     public void set(int index, LispObject newValue) throws LispError
    69     {
    70         try {
    71             slots[index] = newValue;
    72         }
    73         catch (ArrayIndexOutOfBoundsException e) {
    74             getStandardOutput().printStackTrace(e);
    75             throw new LispError("internal error");
    76         }
    7755    }
    7856
     
    10179        {
    10280            try {
    103                 return ((StructureObject)first).get(((Fixnum)second).getValue());
    104             }
    105             catch (ClassCastException e) {
    106                 throw new TypeError();
     81                return ((StructureObject)first).slots[((Fixnum)second).getValue()];
     82            }
     83            catch (ClassCastException e) {
     84                throw new TypeError();
     85            }
     86            catch (ArrayIndexOutOfBoundsException e) {
     87                getStandardOutput().printStackTrace(e);
     88                throw new LispError("internal error");
    10789            }
    10890        }
     
    11496        {
    11597            try {
    116                 return ((StructureObject)arg).get(0);
    117             }
    118             catch (ClassCastException e) {
    119                 throw new TypeError();
     98                return ((StructureObject)arg).slots[0];
     99            }
     100            catch (ClassCastException e) {
     101                throw new TypeError();
     102            }
     103            catch (ArrayIndexOutOfBoundsException e) {
     104                getStandardOutput().printStackTrace(e);
     105                throw new LispError("internal error");
    120106            }
    121107        }
     
    127113        {
    128114            try {
    129                 return ((StructureObject)arg).get(1);
    130             }
    131             catch (ClassCastException e) {
    132                 throw new TypeError();
     115                return ((StructureObject)arg).slots[1];
     116            }
     117            catch (ClassCastException e) {
     118                throw new TypeError();
     119            }
     120            catch (ArrayIndexOutOfBoundsException e) {
     121                getStandardOutput().printStackTrace(e);
     122                throw new LispError("internal error");
    133123            }
    134124        }
     
    140130        {
    141131            try {
    142                 return ((StructureObject)arg).get(2);
    143             }
    144             catch (ClassCastException e) {
    145                 throw new TypeError();
     132                return ((StructureObject)arg).slots[2];
     133            }
     134            catch (ClassCastException e) {
     135                throw new TypeError();
     136            }
     137            catch (ArrayIndexOutOfBoundsException e) {
     138                getStandardOutput().printStackTrace(e);
     139                throw new LispError("internal error");
    146140            }
    147141        }
     
    157151        {
    158152            try {
    159                 ((StructureObject)first).set(((Fixnum)second).getValue(), third);
     153                ((StructureObject)first).slots[((Fixnum)second).getValue()] = third;
    160154                return third;
    161155            }
    162156            catch (ClassCastException e) {
    163157                throw new TypeError();
     158            }
     159            catch (ArrayIndexOutOfBoundsException e) {
     160                getStandardOutput().printStackTrace(e);
     161                throw new LispError("internal error");
     162            }
     163        }
     164    };
     165
     166    private static final Primitive1 _STRUCTURE_SET_0 =
     167        new Primitive1("%structure-set-0", PACKAGE_SYS, false) {
     168        public LispObject execute(LispObject first, LispObject second)
     169            throws LispError
     170        {
     171            try {
     172                ((StructureObject)first).slots[0] = second;
     173                return second;
     174            }
     175            catch (ClassCastException e) {
     176                throw new TypeError();
     177            }
     178            catch (ArrayIndexOutOfBoundsException e) {
     179                getStandardOutput().printStackTrace(e);
     180                throw new LispError("internal error");
     181            }
     182        }
     183    };
     184
     185    private static final Primitive1 _STRUCTURE_SET_1 =
     186        new Primitive1("%structure-set-1", PACKAGE_SYS, false) {
     187        public LispObject execute(LispObject first, LispObject second)
     188            throws LispError
     189        {
     190            try {
     191                ((StructureObject)first).slots[1] = second;
     192                return second;
     193            }
     194            catch (ClassCastException e) {
     195                throw new TypeError();
     196            }
     197            catch (ArrayIndexOutOfBoundsException e) {
     198                getStandardOutput().printStackTrace(e);
     199                throw new LispError("internal error");
     200            }
     201        }
     202    };
     203
     204    private static final Primitive1 _STRUCTURE_SET_2 =
     205        new Primitive1("%structure-set-2", PACKAGE_SYS, false) {
     206        public LispObject execute(LispObject first, LispObject second)
     207            throws LispError
     208        {
     209            try {
     210                ((StructureObject)first).slots[2] = second;
     211                return second;
     212            }
     213            catch (ClassCastException e) {
     214                throw new TypeError();
     215            }
     216            catch (ArrayIndexOutOfBoundsException e) {
     217                getStandardOutput().printStackTrace(e);
     218                throw new LispError("internal error");
    164219            }
    165220        }
Note: See TracChangeset for help on using the changeset viewer.