Changeset 8229


Ignore:
Timestamp:
12/07/04 17:46:07 (17 years ago)
Author:
piso
Message:

Work in progress.

File:
1 edited

Legend:

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

    r8224 r8229  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: CharacterFunctions.java,v 1.11 2004-12-07 04:16:06 piso Exp $
     5 * $Id: CharacterFunctions.java,v 1.12 2004-12-07 17:46:07 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2828        new Primitive("char=", "&rest characters")
    2929    {
     30        public LispObject execute() throws ConditionThrowable
     31        {
     32            return signal(new WrongNumberOfArgumentsException(this));
     33        }
     34        public LispObject execute(LispObject arg) throws ConditionThrowable
     35        {
     36            if (arg instanceof LispCharacter)
     37                return T;
     38            return signal(new TypeError(arg, Symbol.CHARACTER));
     39        }
    3040        public LispObject execute(LispObject first, LispObject second)
    3141            throws ConditionThrowable
     
    4656        {
    4757            final int length = array.length;
    48             if (length == 0)
    49                 return signal(new WrongNumberOfArgumentsException(this));
    50             if (length > 1) {
    51                 final char c0 = LispCharacter.getValue(array[0]);
    52                 for (int i = 0; i < length; i++) {
    53                     if (c0 != LispCharacter.getValue(array[i]))
    54                         return NIL;
    55                 }
     58            final char c0 = LispCharacter.getValue(array[0]);
     59            for (int i = 0; i < length; i++) {
     60                if (c0 != LispCharacter.getValue(array[i]))
     61                    return NIL;
    5662            }
    5763            return T;
     
    6369        new Primitive("char-equal", "&rest characters")
    6470    {
     71        public LispObject execute() throws ConditionThrowable
     72        {
     73            return signal(new WrongNumberOfArgumentsException(this));
     74        }
     75        public LispObject execute(LispObject arg) throws ConditionThrowable
     76        {
     77            if (arg instanceof LispCharacter)
     78                return T;
     79            return signal(new TypeError(arg, Symbol.CHARACTER));
     80        }
    6581        public LispObject execute(LispObject first, LispObject second)
    6682            throws ConditionThrowable
     
    7995        {
    8096            final int length = array.length;
    81             if (length == 0)
    82                 return signal(new WrongNumberOfArgumentsException(this));
    83             if (length > 1) {
    84                 final char c0 = LispCharacter.getValue(array[0]);
    85                 for (int i = 1; i < length; i++) {
    86                     char c = LispCharacter.getValue(array[i]);
    87                     if (c0 == c)
    88                         continue;
    89                     if (Utilities.toUpperCase(c0) == Utilities.toUpperCase(c))
    90                         continue;
    91                     if (Utilities.toLowerCase(c0) == Utilities.toLowerCase(c))
    92                         continue;
    93                     return NIL;
    94                 }
     97            final char c0 = LispCharacter.getValue(array[0]);
     98            for (int i = 1; i < length; i++) {
     99                char c = LispCharacter.getValue(array[i]);
     100                if (c0 == c)
     101                    continue;
     102                if (Utilities.toUpperCase(c0) == Utilities.toUpperCase(c))
     103                    continue;
     104                if (Utilities.toLowerCase(c0) == Utilities.toLowerCase(c))
     105                    continue;
     106                return NIL;
    95107            }
    96108            return T;
     
    100112    // ### char-greaterp
    101113    private static final Primitive CHAR_GREATERP =
    102         new Primitive("char-greaterp","&rest characters") {
     114        new Primitive("char-greaterp", "&rest characters")
     115    {
     116        public LispObject execute() throws ConditionThrowable
     117        {
     118            return signal(new WrongNumberOfArgumentsException(this));
     119        }
     120        public LispObject execute(LispObject arg) throws ConditionThrowable
     121        {
     122            if (arg instanceof LispCharacter)
     123                return T;
     124            return signal(new TypeError(arg, Symbol.CHARACTER));
     125        }
    103126        public LispObject execute(LispObject first, LispObject second)
    104127            throws ConditionThrowable
     
    111134        {
    112135            final int length = array.length;
    113             if (length == 0)
    114                 return signal(new WrongNumberOfArgumentsException(this));
    115             if (length > 1) {
    116                 char[] chars = new char[length];
    117                 for (int i = 0; i < length; i++)
    118                     chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
    119                 for (int i = 1; i < length; i++) {
    120                     if (chars[i-1] <= chars[i])
    121                         return NIL;
    122                 }
     136            char[] chars = new char[length];
     137            for (int i = 0; i < length; i++)
     138                chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
     139            for (int i = 1; i < length; i++) {
     140                if (chars[i-1] <= chars[i])
     141                    return NIL;
    123142            }
    124143            return T;
     
    128147    // ### char-not-greaterp
    129148    private static final Primitive CHAR_NOT_GREATERP =
    130         new Primitive("char-not-greaterp","&rest characters") {
     149        new Primitive("char-not-greaterp", "&rest characters")
     150    {
     151        public LispObject execute() throws ConditionThrowable
     152        {
     153            return signal(new WrongNumberOfArgumentsException(this));
     154        }
     155        public LispObject execute(LispObject arg) throws ConditionThrowable
     156        {
     157            if (arg instanceof LispCharacter)
     158                return T;
     159            return signal(new TypeError(arg, Symbol.CHARACTER));
     160        }
    131161        public LispObject execute(LispObject first, LispObject second)
    132162            throws ConditionThrowable
     
    139169        {
    140170            final int length = array.length;
    141             if (length == 0)
    142                 return signal(new WrongNumberOfArgumentsException(this));
    143             if (length > 1) {
    144                 char[] chars = new char[length];
    145                 for (int i = 0; i < length; i++)
    146                     chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
    147                 for (int i = 1; i < length; i++) {
    148                     if (chars[i] < chars[i-1])
    149                         return NIL;
    150                 }
     171            char[] chars = new char[length];
     172            for (int i = 0; i < length; i++)
     173                chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
     174            for (int i = 1; i < length; i++) {
     175                if (chars[i] < chars[i-1])
     176                    return NIL;
    151177            }
    152178            return T;
     
    278304        new Primitive("char-lessp", "&rest characters")
    279305    {
     306        public LispObject execute() throws ConditionThrowable
     307        {
     308            return signal(new WrongNumberOfArgumentsException(this));
     309        }
     310        public LispObject execute(LispObject arg) throws ConditionThrowable
     311        {
     312            if (arg instanceof LispCharacter)
     313                return T;
     314            return signal(new TypeError(arg, Symbol.CHARACTER));
     315        }
    280316        public LispObject execute(LispObject first, LispObject second)
    281317            throws ConditionThrowable
     
    288324        {
    289325            final int length = array.length;
    290             if (length == 0)
    291                 return signal(new WrongNumberOfArgumentsException(this));
    292             if (length > 1) {
    293                 char[] chars = new char[length];
    294                 for (int i = 0; i < length; i++)
    295                     chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
    296                 for (int i = 1; i < length; i++) {
    297                     if (chars[i-1] >= chars[i])
    298                         return NIL;
    299                 }
     326            char[] chars = new char[length];
     327            for (int i = 0; i < length; i++)
     328                chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
     329            for (int i = 1; i < length; i++) {
     330                if (chars[i-1] >= chars[i])
     331                    return NIL;
    300332            }
    301333            return T;
     
    307339        new Primitive("char-not-lessp", "&rest characters")
    308340    {
     341        public LispObject execute() throws ConditionThrowable
     342        {
     343            return signal(new WrongNumberOfArgumentsException(this));
     344        }
     345        public LispObject execute(LispObject arg) throws ConditionThrowable
     346        {
     347            if (arg instanceof LispCharacter)
     348                return T;
     349            return signal(new TypeError(arg, Symbol.CHARACTER));
     350        }
    309351        public LispObject execute(LispObject first, LispObject second)
    310352            throws ConditionThrowable
     
    317359        {
    318360            final int length = array.length;
    319             if (length == 0)
    320                 return signal(new WrongNumberOfArgumentsException(this));
    321             if (length > 1) {
    322                 char[] chars = new char[length];
    323                 for (int i = 0; i < length; i++)
    324                     chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
    325                 for (int i = 1; i < length; i++) {
    326                     if (chars[i] > chars[i-1])
    327                         return NIL;
    328                 }
     361            char[] chars = new char[length];
     362            for (int i = 0; i < length; i++)
     363                chars[i] = Utilities.toUpperCase(LispCharacter.getValue(array[i]));
     364            for (int i = 1; i < length; i++) {
     365                if (chars[i] > chars[i-1])
     366                    return NIL;
    329367            }
    330368            return T;
Note: See TracChangeset for help on using the changeset viewer.