1. 27 Jan, 2014 4 commits
  2. 26 Jan, 2014 2 commits
  3. 25 Jan, 2014 4 commits
  4. 22 Jan, 2014 2 commits
  5. 19 Jan, 2014 2 commits
  6. 16 Jan, 2014 3 commits
    • mevenson@1c010e3e-69d0-11dd-93a8-456734b0d56f's avatar
      fcd3132a
    • mevenson@1c010e3e-69d0-11dd-93a8-456734b0d56f's avatar
      Restore the run-to-completion quality of the ABCL test suite. · d64bb250
      Something is seriously borked with loading fasls via HTTP.  Currently,
      trying to get a jdb version of ABCL running under Netbeans, connected
      to via SLIME to debug this.
      d64bb250
    • mevenson@1c010e3e-69d0-11dd-93a8-456734b0d56f's avatar
      Fix gray streams for FLEXI-STREAMS. · 8a3fbb66
      From Theam Yang Chew, who writes on
      http://article.gmane.org/gmane.lisp.armedbear.devel/3059:
      
      Hi all,
      
      I inadvertently discovered some bugs in the gray-streams
      implementation due to a stale flexi-streams that did not get upgraded
      properly.
      
      There were quite a few things that needed tidying - the type checking
      using EQ is wrong. Also, after trying to hunt around CLHS, I think
      BYTE is not a CL type (though I may be mistaken). This could be a
      reflection of some Corman Lisp specific feature in the past (Yes!
      These bugs seem to have been around ABCL for that long!)
      
      Some test examples (avoiding flexi-streams or other dependencies)
      
      ;; ----- setup
      
      (require 'gray-streams)
      
      (defclass test-gray-binary-input-stream
      (gray-streams:fundamental-binary-input-stream)
       ())
      
      (defclass test-gray-character-input-stream
      (gray-streams:fundamental-character-input-stream)
       ())
      
      (let ((bytes (list 65 66 67 68 69))
           (pos -1))
       (defmethod gray-streams::stream-read-byte ((stream
      test-gray-binary-input-stream))
         (elt bytes (mod (incf pos) 5))))
      
      (let ((chars (list #\A #\B #\C #\D #\E))
           (pos -1))
       (defmethod gray-streams::stream-read-char ((stream
      test-gray-character-input-stream))
         (elt chars (mod (incf pos) 5))))
      
      ;; -----
      
      (let ((s (make-instance 'test-gray-binary-input-stream)))
       (loop repeat 10 collect (read-byte s)))
      => (65 66 67 68 69 65 66 67 68 69)
      
      (let ((arr (make-array 10 :initial-element nil)))
       (list (read-sequence arr
                            (make-instance 'test-gray-binary-input-stream)
                            :start 2 :end 7)
             arr))
      
      Expected (7 #(NIL NIL 65 66 67 68 69 NIL NIL NIL)), but got an error
      instead, ... no applicable method...
      
      I guess implementors of gray streams would normally define both
      read-byte & read-sequence. But ABCL's default/fallback method does try
      to support binary streams, it just isn't being dispatched on the right
      class.
      
      Also, read-sequence should return the "final" array index, not the
      number of bytes/characters read. Similarly, write-sequence needs to do
      its work, then return the sequence itself.
      
      Attached is a patch with what I hope are the required fixes, please
      review.
      
      Two additional notes,
      
      1. Even after loading my proposed fixes, I'd would still get this,
      which is ok, but the error message is not obvious enough. This is
      actually a method not found error, not a type error. There appears
      to be some type guessing going on, so perhaps the message should
      indicate failure to dispatch on STREAM or similar.
      
      (gray-streams::stream-element-type
      (make-instance 'test-gray-binary-input-stream))
      The value #<TEST-GRAY-BINARY-INPUT-STREAM {500BBBF9}> is not of type STREAM.
        [Condition of type TYPE-ERROR]
      
      So we just need something like this,
      
      (defmethod gray-streams::stream-element-type ((stream
      test-gray-binary-input-stream))
       '(unsigned-byte 8))
      
      2. I also don't understand this snippet in the original code,
      converting unsigned-bytes/integers (basically the wrong type) to a
      character?
      
      (#+nil ccl:int-char code-char (elt sequence n))
      
      
      Of course, after patching the above, I discovered that re-compiling
      flexi-streams
      got rid of my particular set of problems :-)
      8a3fbb66
  7. 11 Jan, 2014 1 commit
  8. 09 Jan, 2014 2 commits
  9. 05 Jan, 2014 5 commits
  10. 04 Jan, 2014 1 commit
  11. 03 Jan, 2014 1 commit
    • mevenson@1c010e3e-69d0-11dd-93a8-456734b0d56f's avatar
      SLIME configuation under NetBeans working again. · c9863ca1
      To use slime, ensure the directory "~/.asdf-install-dir/systems"
      exits, and symlink `swank.asd` from a SLIME installation into it.
      Start the "slime" Netbeans configuration: when you see the "Swank
      started at port: 4005."  message, you may then use Emacs M-x
      slime-connect to attach to the ABCL instance running in Netbeans.
      
      An improvement might to be to randomize the port given to
      SWANK:CREATE-SERVER somehow.
      
      Updated artifacts to Netbeans 7.4.
      c9863ca1
  12. 27 Dec, 2013 1 commit
  13. 05 Dec, 2013 2 commits
  14. 24 Nov, 2013 1 commit
  15. 10 Nov, 2013 1 commit
  16. 09 Nov, 2013 3 commits
  17. 02 Nov, 2013 1 commit
  18. 01 Nov, 2013 1 commit
  19. 27 Aug, 2013 1 commit
  20. 19 Aug, 2013 1 commit
  21. 18 Aug, 2013 1 commit
    • mevenson@1c010e3e-69d0-11dd-93a8-456734b0d56f's avatar
      Lazily create the little used portions of the Lisp stack. · 134eb4b3
      Aggressively cache and control the use of memory by the underlying
      Lisp stack frame representation by introducing the private
      LispThread.StackFrame and LispThread.StackSegments classes.
      
      Dmitry Nadezhin contributes the following:
      
         LispStackFrame object are allocated on every
         LispThread.execute(...) .
      
         However, they are seldom [accessed] ([... verify via] inspect[tion
         of the] stack trace).  This patch delays allocation of
         LispStackFrame objects until they are requested.
      
         Raw information about stack frames is stored in stack.  Stack is an
         Object[] array (more precisely a list of [...]4 [Mib] Object[]
         arrays).
      
      Implement org.armedbear.lisp.protocol.Inspectable on StackSegment
      (incomplete).  We are going to need a way to try to less agressively
      grab 4Mib chunks in low memory situations.
      
      Promote comments to javadoc in LispThread where it makes sense
      (incomplete).
      
      Remove "first", "second", "third" accessor forms in LispStackFrame in
      favor of exclusive use of varargs.  This may affect usage on pre
      jre-1.5.0 JVMs.  Users who have trouble with this requirement should
      consider weaving pre-1.5 bytecode with appropiate thunks for vararg
      calls.
      134eb4b3