Changeset 5888


Ignore:
Timestamp:
02/22/04 15:57:34 (17 years ago)
Author:
piso
Message:

Moved Lisp functions to StringFunctions?.java.

File:
1 edited

Legend:

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

    r5872 r5888  
    33 *
    44 * Copyright (C) 2002-2004 Peter Graves
    5  * $Id: LispString.java,v 1.82 2004-02-19 01:34:28 piso Exp $
     5 * $Id: LispString.java,v 1.83 2004-02-22 15:57:34 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    445445        return toString(0, chars.length);
    446446    }
    447 
    448     // ### string-p
    449     public static final Primitive1 STRINGP = new Primitive1("stringp", "object")
    450     {
    451         public LispObject execute(LispObject arg) throws ConditionThrowable
    452         {
    453             // Displaced arrays might be strings.
    454             return arg.STRINGP();
    455         }
    456     };
    457 
    458     // ### simple-string-p
    459     public static final Primitive1 SIMPLE_STRING_P =
    460         new Primitive1("simple-string-p", "object")
    461     {
    462         public LispObject execute(LispObject arg) throws ConditionThrowable
    463         {
    464             return arg.SIMPLE_STRING_P();
    465         }
    466     };
    467 
    468     // ### %make-string
    469     // %make-string size initial-element element-type => string
    470     // Returns a simple string.
    471     private static final Primitive3 _MAKE_STRING =
    472         new Primitive3("%make-string", PACKAGE_SYS, false)
    473     {
    474         public LispObject execute(LispObject size, LispObject initialElement,
    475                                   LispObject elementType) throws ConditionThrowable
    476         {
    477             final int n = Fixnum.getValue(size);
    478             final int limit =
    479                 Fixnum.getValue(Symbol.ARRAY_DIMENSION_LIMIT.getSymbolValue());
    480             if (n < 0 || n >= limit) {
    481                 StringBuffer sb = new StringBuffer();
    482                 sb.append("the size specified for this string (");
    483                 sb.append(n);
    484                 sb.append(')');
    485                 if (n >= limit) {
    486                     sb.append(" is >= ARRAY-DIMENSION-LIMIT (");
    487                     sb.append(limit);
    488                     sb.append(')');
    489                 } else
    490                     sb.append(" is negative");
    491                 return signal(new LispError(sb.toString()));
    492             }
    493             // Ignore elementType.
    494             LispString string = new LispString(n);
    495             if (initialElement != NIL) {
    496                 // Initial element was specified.
    497                 char c = checkCharacter(initialElement).getValue();
    498                 string.fill(c);
    499             }
    500             return string;
    501         }
    502     };
    503 
    504     // ### char
    505     private static final Primitive2 CHAR = new Primitive2("char", "string index")
    506     {
    507         public LispObject execute(LispObject first, LispObject second)
    508             throws ConditionThrowable
    509         {
    510             if (first.stringp())
    511                 return ((AbstractArray)first).getRowMajor(Fixnum.getInt(second));
    512             return signal(new TypeError(first, Symbol.STRING));
    513         }
    514     };
    515 
    516     // ### %set-char
    517     private static final Primitive3 _SET_CHAR =
    518         new Primitive3("%set-char", PACKAGE_SYS, false)
    519     {
    520         public LispObject execute(LispObject first, LispObject second,
    521                                   LispObject third) throws ConditionThrowable
    522         {
    523             if (first.stringp()) {
    524                 ((AbstractArray)first).setRowMajor(Fixnum.getInt(second),
    525                                                    checkCharacter(third));
    526                 return third;
    527             }
    528             return signal(new TypeError(first, Symbol.STRING));
    529         }
    530     };
    531 
    532     // ### schar
    533     private static final Primitive2 SCHAR = new Primitive2("schar", "string index") {
    534         public LispObject execute(LispObject first, LispObject second)
    535             throws ConditionThrowable
    536         {
    537             return checkString(first).get(Fixnum.getInt(second));
    538         }
    539     };
    540 
    541     // ### %set-schar
    542     private static final Primitive3 _SET_SCHAR =
    543         new Primitive3("%set-schar", PACKAGE_SYS, false)
    544     {
    545         public LispObject execute(LispObject first, LispObject second,
    546                                   LispObject third) throws ConditionThrowable
    547         {
    548             checkString(first).set(Fixnum.getInt(second), checkCharacter(third));
    549             return third;
    550         }
    551     };
    552 
    553     private static final Primitive3 STRING_POSITION =
    554         new Primitive3("string-position", PACKAGE_EXT, true)
    555     {
    556         public LispObject execute(LispObject first, LispObject second,
    557                                   LispObject third)
    558             throws ConditionThrowable
    559         {
    560             char c = LispCharacter.getValue(first);
    561             LispString string = checkString(second);
    562             int start = Fixnum.getValue(third);
    563             char[] chars = string.chars();
    564             for (int i = start, limit = chars.length; i < limit; i++) {
    565                 if (chars[i] == c)
    566                     return number(i);
    567             }
    568             return NIL;
    569         }
    570     };
    571 
    572     // ### simple-string-search pattern string => position
    573     // Searches string for a substring that matches pattern.
    574     private static final Primitive2 SIMPLE_STRING_SEARCH =
    575         new Primitive2("simple-string-search", PACKAGE_EXT, true)
    576     {
    577         public LispObject execute(LispObject first, LispObject second)
    578             throws ConditionThrowable
    579         {
    580             int index = getValue(second).indexOf(getValue(first));
    581             return index >= 0 ? new Fixnum(index) : NIL;
    582         }
    583     };
    584 
    585     // ### simple-string-fill string character => string
    586     private static final Primitive2 STRING_FILL =
    587         new Primitive2("simple-string-fill", PACKAGE_EXT, true)
    588     {
    589         public LispObject execute(LispObject first, LispObject second)
    590             throws ConditionThrowable
    591         {
    592             checkString(first).fill(LispCharacter.getValue(second));
    593             return first;
    594         }
    595     };
    596447}
Note: See TracChangeset for help on using the changeset viewer.