Changeset 8675


Ignore:
Timestamp:
03/01/05 20:26:04 (16 years ago)
Author:
piso
Message:

Work in progress.

Location:
trunk/j/src/org/armedbear
Files:
2 edited

Legend:

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

    r8461 r8675  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispAPI.java,v 1.59 2005-02-04 04:27:23 piso Exp $
     5 * $Id: LispAPI.java,v 1.60 2005-03-01 20:25:23 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    115115    }
    116116
     117    public static final KeyMap checkKeymap(LispObject obj)
     118        throws ConditionThrowable
     119    {
     120        if (obj == null)
     121            throw new NullPointerException();
     122        try {
     123            return (KeyMap) ((JavaObject)obj).getObject();
     124        }
     125        catch (ClassCastException e) {
     126            signal(new TypeError("The value " + obj.writeToString() +
     127                                 " is not a keymap."));
     128            // Not reached.
     129            return null;
     130        }
     131    }
     132
    117133    private static final Position checkMark(LispObject obj)
    118134        throws ConditionThrowable
     
    390406        {
    391407            Position mark = Editor.currentEditor().getMark();
     408            if (mark == null)
     409                mark = Editor.currentBuffer().getMark();
    392410            if (mark != null)
    393411                return new JavaObject(mark.copy());
    394412            return NIL;
     413        }
     414    };
     415
     416    // ### buffer-mark buffer => mark
     417    private static final Primitive BUFFER_MARK =
     418        new Primitive("buffer-mark", PACKAGE_J, true)
     419    {
     420        public LispObject execute(LispObject arg)
     421            throws ConditionThrowable
     422        {
     423            final Position mark = checkBuffer(arg).getMark();
     424            if (mark == null)
     425                return NIL;
     426            return new JavaObject(mark.copy());
     427        }
     428    };
     429
     430    // ### %set-buffer-mark buffer mark => mark
     431    private static final Primitive _SET_BUFFER_MARK =
     432        new Primitive("%set-buffer-mark", PACKAGE_J, true)
     433    {
     434        public LispObject execute(LispObject first, LispObject second)
     435            throws ConditionThrowable
     436        {
     437            Buffer buffer = checkBuffer(first);
     438            if (second == NIL)
     439                buffer.setMark(null);
     440            else
     441                buffer.setMark(checkMark(second));
     442            return second;
     443        }
     444    };
     445
     446    // ### editor-mark editor => mark
     447    private static final Primitive EDITOR_MARK =
     448        new Primitive("editor-mark", PACKAGE_J, true)
     449    {
     450        public LispObject execute(LispObject arg)
     451            throws ConditionThrowable
     452        {
     453            final Position mark = checkEditor(arg).getMark();
     454            if (mark == null)
     455                return NIL;
     456            return new JavaObject(mark.copy());
     457        }
     458    };
     459
     460    // ### %set-editor-mark editor mark => mark
     461    private static final Primitive _SET_EDITOR_MARK =
     462        new Primitive("%set-editor-mark", PACKAGE_J, true)
     463    {
     464        public LispObject execute(LispObject first, LispObject second)
     465            throws ConditionThrowable
     466        {
     467            Editor editor = checkEditor(first);
     468            if (second == NIL)
     469                editor.setMark(null);
     470            else
     471                editor.setMark(checkMark(second));
     472            return second;
    395473        }
    396474    };
     
    876954    };
    877955
     956    // ### make-keymap
     957    private static final Primitive MAKE_KEYMAP =
     958        new Primitive("make-keymap", PACKAGE_J, true, "")
     959    {
     960        public LispObject execute()
     961        {
     962            return new JavaObject(new KeyMap());
     963        }
     964    };
     965
     966    // ### use-global-map keymap => NIL
     967    private static final Primitive SET_GLOBAL_KEYMAP =
     968        new Primitive("use-global-map", PACKAGE_J, true, "keymap")
     969    {
     970        public LispObject execute(LispObject arg)
     971            throws ConditionThrowable
     972        {
     973            KeyMap.setGlobalKeyMap(checkKeymap(arg));
     974            return T;
     975        }
     976    };
     977
     978    // ### define-key keymap key definition => generalized-boolean
     979    private static final Primitive DEFINE_KEY =
     980        new Primitive("define-key", PACKAGE_J, true, "keymap key definition")
     981    {
     982        public LispObject execute(LispObject first, LispObject second,
     983                                  LispObject third)
     984      throws ConditionThrowable
     985        {
     986            KeyMap keymap = checkKeymap(first);
     987            String keyText = second.getStringValue();
     988            Object command;
     989            if (third instanceof AbstractString) {
     990                command = third.getStringValue();
     991            } else if (third instanceof JavaObject) {
     992                command = checkKeymap(third);
     993            } else {
     994                // Verify that the command can be coerced to a function.
     995                coerceToFunction(third);
     996                command = third;
     997            }
     998            return keymap.mapKey(keyText, command) ? T : NIL;
     999        }
     1000    };
     1001
    8781002    // ### global-map-key key command => generalized-boolean
    8791003    private static final Primitive GLOBAL_MAP_KEY =
     
    8871011            if (second instanceof AbstractString) {
    8881012                command = second.getStringValue();
     1013            } else if (second instanceof JavaObject) {
     1014                command = checkKeymap(second);
    8891015            } else {
    8901016                // Verify that the command can be coerced to a function.
     
    12631389    };
    12641390
    1265     // ### %status string => generalized-boolean
     1391    // ### %status string &optional editor => generalized-boolean
    12661392    private static final Primitive STATUS =
    1267         new Primitive("status", PACKAGE_J, true, "string")
     1393        new Primitive("status", PACKAGE_J, true, "string &optional editor")
    12681394    {
    12691395        public LispObject execute(LispObject arg) throws ConditionThrowable
     
    12871413            return signal(new TypeError(arg, Symbol.STRING));
    12881414        }
     1415
    12891416        public LispObject execute(LispObject first, LispObject second)
    12901417            throws ConditionThrowable
  • trunk/j/src/org/armedbear/lisp/j.lisp

    r8460 r8675  
    22;;;
    33;;; Copyright (C) 2003-2005 Peter Graves
    4 ;;; $Id: j.lisp,v 1.40 2005-02-04 04:27:44 piso Exp $
     4;;; $Id: j.lisp,v 1.41 2005-03-01 20:26:04 piso Exp $
    55;;;
    66;;; This program is free software; you can redistribute it and/or
     
    9191          set-mark
    9292          status
    93           status
    9493          switch-to-buffer
    9594          undo
     
    198197(defsetf current-editor %set-current-editor)
    199198
     199(defsetf buffer-mark %set-buffer-mark)
     200
     201(defsetf editor-mark %set-editor-mark)
     202
    200203(defsetf line-flags %set-line-flags)
    201204
Note: See TracChangeset for help on using the changeset viewer.