Changeset 5996


Ignore:
Timestamp:
02/26/04 20:39:10 (17 years ago)
Author:
piso
Message:

Work in progress.

File:
1 edited

Legend:

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

    r5760 r5996  
    33 *
    44 * Copyright (C) 2003-2004 Peter Graves
    5  * $Id: LispAPI.java,v 1.31 2004-02-11 02:32:53 piso Exp $
     5 * $Id: LispAPI.java,v 1.32 2004-02-26 20:39:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2525import javax.swing.SwingUtilities;
    2626import javax.swing.undo.CompoundEdit;
     27import org.armedbear.lisp.AbstractString;
    2728import org.armedbear.lisp.ConditionThrowable;
    2829import org.armedbear.lisp.Fixnum;
     
    3536import org.armedbear.lisp.LispError;
    3637import org.armedbear.lisp.LispObject;
    37 import org.armedbear.lisp.LispString;
    3838import org.armedbear.lisp.LispThread;
    3939import org.armedbear.lisp.Package;
     
    4545import org.armedbear.lisp.Primitive;
    4646import org.armedbear.lisp.Primitives;
     47import org.armedbear.lisp.SimpleString;
    4748import org.armedbear.lisp.Symbol;
    4849import org.armedbear.lisp.TypeError;
     
    180181            if (file != null) {
    181182                if (file.isRemote())
    182                     return new LispString(file.netPath());
    183                 return new LispString(file.canonicalPath());
     183                    return new SimpleString(file.netPath());
     184                return new SimpleString(file.canonicalPath());
    184185            }
    185186            return NIL;
     
    192193        public LispObject execute() throws ConditionThrowable
    193194        {
    194             return new LispString(Editor.currentBuffer().getText());
    195         }
    196         public LispObject execute(LispObject arg) throws ConditionThrowable
    197         {
    198             return new LispString(checkBuffer(arg).getText());
     195            return new SimpleString(Editor.currentBuffer().getText());
     196        }
     197        public LispObject execute(LispObject arg) throws ConditionThrowable
     198        {
     199            return new SimpleString(checkBuffer(arg).getText());
    199200        }
    200201    };
     
    341342        {
    342343            String s = checkLine(arg).getText();
    343             return s != null ? new LispString(s) : NIL;
     344            return s != null ? new SimpleString(s) : NIL;
    344345        }
    345346    };
     
    517518                    return number(buffer.getIntegerProperty(property));
    518519                String value = buffer.getStringProperty(property);
    519                 return value != null ? new LispString(value) : NIL;
     520                return value != null ? new SimpleString(value) : NIL;
    520521            }
    521522            if (kind == KEYWORD_GLOBAL) {
     
    525526                    return number(preferences.getIntegerProperty(property));
    526527                String value = preferences.getStringProperty(property);
    527                 return value != null ? new LispString(value) : NIL;
     528                return value != null ? new SimpleString(value) : NIL;
    528529            }
    529530            if (kind == KEYWORD_MODE) {
     
    532533                    mode = editor.getMode();
    533534                else {
    534                     mode = Editor.getModeList().getModeFromModeName(LispString.getValue(where));
     535                    mode = Editor.getModeList().getModeFromModeName(where.getStringValue());
    535536                    if (mode == null)
    536537                        return signal(new LispError("Unknown mode: " + where + "."));
     
    541542                    return number(mode.getIntegerProperty(property));
    542543                String value = mode.getStringProperty(property);
    543                 return value != null ? new LispString(value) : NIL;
     544                return value != null ? new SimpleString(value) : NIL;
    544545            }
    545546            if (kind == KEYWORD_BUFFER) {
     
    554555                    return number(buffer.getIntegerProperty(property));
    555556                String value = buffer.getStringProperty(property);
    556                 return value != null ? new LispString(value) : NIL;
     557                return value != null ? new SimpleString(value) : NIL;
    557558            }
    558559            return signal(new LispError("Invalid parameter: " + kind + "."));
     
    584585                    }
    585586                } else {
    586                     preferences.setProperty(property, LispString.getValue(newValue));
     587                    preferences.setProperty(property, newValue.getStringValue());
    587588                    return newValue;
    588589                }
     
    594595                    mode = editor.getMode();
    595596                else
    596                     mode = Editor.getModeList().getModeFromModeName(LispString.getValue(where));
     597                    mode = Editor.getModeList().getModeFromModeName(where.getStringValue());
    597598                if (property.isBooleanProperty()) {
    598599                    if (newValue == NIL) {
     
    604605                    }
    605606                } else {
    606                     mode.setProperty(property, LispString.getValue(newValue));
     607                    mode.setProperty(property, newValue.getStringValue());
    607608                    return newValue;
    608609                }
     
    622623                    return newValue;
    623624                }
    624                 buffer.setProperty(property, LispString.getValue(newValue));
     625                buffer.setProperty(property, newValue.getStringValue());
    625626                return newValue;
    626627            }
     
    655656      throws ConditionThrowable
    656657        {
    657             String keyText = LispString.getValue(first);
     658            String keyText = first.getStringValue();
    658659            Object command;
    659             if (second instanceof LispString) {
    660                 command = ((LispString)second).getValue();
     660            if (second instanceof AbstractString) {
     661                command = second.getStringValue();
    661662            } else {
    662663                // Verify that the command can be coerced to a function.
     
    674675      throws ConditionThrowable
    675676        {
    676             String keyText = LispString.getValue(arg);
     677            String keyText = arg.getStringValue();
    677678            return KeyMap.getGlobalKeyMap().unmapKey(keyText) ? T : NIL;
    678679        }
     
    686687      throws ConditionThrowable
    687688        {
    688             String keyText = LispString.getValue(first);
     689            String keyText = first.getStringValue();
    689690            Object command;
    690             if (second instanceof LispString) {
    691                 command = ((LispString)second).getValue();
     691            if (second instanceof AbstractString) {
     692                command = second.getStringValue();
    692693            } else {
    693694                // Verify that the command can be coerced to a function.
     
    695696                command = second;
    696697            }
    697             String modeName = LispString.getValue(third);
     698            String modeName = third.getStringValue();
    698699            Mode mode = Editor.getModeList().getModeFromModeName(modeName);
    699700            if (mode == null)
     
    709710      throws ConditionThrowable
    710711        {
    711             String keyText = LispString.getValue(first);
    712             String modeName = LispString.getValue(second);
     712            String keyText = first.getStringValue();
     713            String modeName = second.getStringValue();
    713714            Mode mode = Editor.getModeList().getModeFromModeName(modeName);
    714715            if (mode == null)
     
    724725      throws ConditionThrowable
    725726        {
    726             String key = LispString.getValue(first);
     727            String key = first.getStringValue();
    727728            final String value;
    728729            if (second instanceof Fixnum)
    729730                value = String.valueOf(Fixnum.getValue(second));
    730731            else
    731                 value = LispString.getValue(second);
     732                value = second.getStringValue();
    732733            Editor.setGlobalProperty(key, value);
    733734            return second;
     
    751752                    if (obj instanceof LispCharacter) {
    752753                        editor.insertChar(((LispCharacter)obj).getValue());
    753                     } else if (obj instanceof LispString) {
    754                         editor.insertString(((LispString)obj).getValue());
     754                    } else if (obj instanceof AbstractString) {
     755                        editor.insertString(obj.getStringValue());
    755756                    } else
    756757                        throw new ConditionThrowable(new TypeError(obj, "character or string"));
     
    796797        public LispObject execute(LispObject arg) throws ConditionThrowable
    797798        {
    798             Log.debug(LispString.getValue(arg));
     799            Log.debug(arg.getStringValue());
    799800            return arg;
    800801        }
Note: See TracChangeset for help on using the changeset viewer.