Changes between Version 1 and Version 2 of ReleaseNotes


Ignore:
Timestamp:
Nov 9, 2007, 12:00:33 AM (12 years ago)
Author:
gb
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • ReleaseNotes

    v1 v2  
    1 OpenMCL 1.1-pre-070722
     1= OpenMCL 1.1-pre-070722 =
    22- This will hopefully be the last set of snapshots whose version
    33  number contains the string "pre-"; whether or not the last
     
    1919  broken) is now exported and somewhat less broken.
    2020
     21{{{
    2122  (ccl:with-encoded-cstrs ENCODING-NAME ((varI stringI)*) &body body)
     23}}}
    2224
    2325  where ENCODING-NAME is a keyword constant that names a character
     
    2628  an encoded version of the corresponding stringI.
    2729
     30{{{
    2831  (ccl:with-cstrs ((x "x")) (#_puts x))
     32}}}
    2933
    3034  is functionally equivalent to:
    3135
     36{{{
    3237  (ccl:with-encoded-cstrs :iso-8859-1 ((x "x")) (#_puts x))
     38}}}
    3339
    3440
     
    188194
    189195
    190 OpenMCL 1.1-pre-070512
     196= OpenMCL 1.1-pre-070512 =
    191197- The FASL version changed (old FASL files won't work with this
    192198  lisp version), as did the version information which tries to
     
    218224  than something like
    219225
     226{{{
    220227  (let* ((stream (open pathname :direction :input :element-type 'whatever))
    221228         (vector (make-array (file-size-to-vector-size stream)
    222229                             :element-type 'whatever)))
    223230    (read-sequence vector stream))
     231}}}
    224232
    225233  but has the similar effect of making the contents of VECTOR match the
    226234  contents of the file.)
    227235
    228   CCL:MAP-FILE-TO-IVECTOR pathname element-type [Function]
     236{{{CCL:MAP-FILE-TO-IVECTOR pathname element-type [Function]}}}
    229237
    230238  "element-type" should be a type specifier such that
     
    253261  will result in memory faults.
    254262 
    255   CCL:MAP-FILE-TO-OCTET-VECTOR pathname [Function]
     263  {{{CCL:MAP-FILE-TO-OCTET-VECTOR pathname [Function]}}}
    256264
    257265  Equivalent to (CCL:MAP-FILE-TO-IVECTOR pathname '(UNSIGNED-BYTE 8)).
    258266
    259   CCL:UNMAP-IVECTOR displaced-vector
     267  {{{CCL:UNMAP-IVECTOR displaced-vector}}}
    260268
    261269  If the argument is a mapped vector (as returned by
     
    274282  running lisp code as lisp errors.  As a silly example:
    275283
     284{{{
    276285  ? (defun foo (x)
    277286     "Crash and burn if X is not a list"
     
    282291  > Error: Fault during read of memory address #x4
    283292  > While executing: FOO, in process listener(1).
     293}}}
    284294
    285295  The fact that things are handled this way (rather than going
     
    313323
    314324
    315 OpenMCL 1.1-pre-070408
     325= OpenMCL 1.1-pre-070408 =
    316326- The FASL version changed (old FASL files won't work with this
    317327  lisp version), as did the version information which tries to
     
    475485  class object as its value.  In other words:
    476486
     487{{{
    477488(send (find-class 'ns:ns-application) 'shared-application)
     489}}}
    478490
    479491  and
    480492
     493{{{
    481494(send ns:ns-application 'shared-application)
     495}}}
    482496
    483497  are equivalent.  (Since it's not legal to bind a "static" variable,
     
    543557  Some examples:
    544558
     559{{{
    545560;;; #/alloc is a known message.
    546561? #'#/alloc
     
    558573
    559574(#/init (#/alloc ns:ns-object))
     575}}}
    560576
    561577  ObjC methods that "return" structures return them as gcable pointers
     
    563579  NS:NS-WINDOW instance, then
    564580
     581{{{
    565582(#/frame my-window)
     583}}}
    566584
    567585  will return a gcable pointer to a structure that describes that window's
     
    617635    bound to that instance.  E.g.
    618636
     637{{{
    619638    (ns:with-ns-range (r loc len)
    620639      (format t "~& range has location ~s, length ~s"
    621640         (ns:ns-range-location r) (ns:ns-range-length r)))
     641}}}
    622642
    623643    which is probably not the world's most realistic example.
     
    626646   instance that has a very short useful lifetime:
    627647
     648{{{
    628649   (#/initWithFrame: new-view (ns:ns-make-rect 100 100 200 200))
     650}}}
    629651
    630652   The rectangle above will -eventually- get reclaimed by the GC;
     
    632654   prefer to do:
    633655
     656{{{
    634657   (ns:with-ns-rect (r 100 100 200 200)
    635658     (#/initWithFrame: new-view r))
     659}}}
    636660
    637661
     
    640664   The syntax is:
    641665
    642    (OBC:DEFMETHOD name-and-result-type ((receiver-arg-and-class) &rest other-args) &body body)
     666   {{{ (OBC:DEFMETHOD name-and-result-type ((receiver-arg-and-class) &rest other-args) &body body) }}}
    643667
    644668   where:
     
    663687  For example:
    664688
     689{{{
    665690(objc:defmethod (#/characterAtIndex: :unichar)
    666691    ((self hemlock-buffer-string) (index :<NSUI>nteger))
    667692  ...)
     693}}}
    668694 
    669695  The method "characterAtIndex:", when invoked on an object of class
     
    699725  structure:
    700726
     727{{{
    701728  (objc:defmethod (#/reallyTinyRectangleAtPoint: :ns-rect)
    702729    ((self really-tiny-view) (where :ns-point))
     
    705732                          single-float-epsilon single-float-epsilon)
    706733      r))
     734}}}
    707735
    708736 - If OBJC:DEFMETHOD introduces a new ObjC message, a ... message
     
    726754   do that is via the new function OBJC:LOAD-FRAMEWORK
    727755
    728    (OBJC:LOAD-FRAMEWORK framework-name interface-dir)
     756   {{{ (OBJC:LOAD-FRAMEWORK framework-name interface-dir) }}}
    729757
    730758   where "framework-name" is a string which names the framework and
     
    760788
    761789
    762 OpenMCL 1.1-pre-070214
     790= OpenMCL 1.1-pre-070214 =
    763791- The FASL version changed (old FASL files won't work with this
    764792  lisp version), as did the version information which tries to
     
    817845  For example, if a :rect structure is defined as:
    818846
     847{{{
    819848  (def-foreign-type nil
    820849    (:struct :rect
     
    823852      (:x :int)  ; x coordinate of origin
    824853      (:y :int)))
     854}}}
    825855
    826856  and a foreign function named "inset_rect" takes a rect and an integer
     
    828858  foreign function might look like:
    829859
     860{{{
    830861  (rlet ((result :rect))
    831862    (ff-call *address-of-inset-rect* result (:struct :rect) r :int delta :(:struct rect))
    832863    ;; or, if "inset_rect" was declared in the interface database:
    833864    (#_inset_rect result r delta))
    834 
     865}}}
    835866
    836867  A callback that returns a :rect likewise should accept a pointer
     
    838869  and explicitly declare that it returns a (:STRUCT :RECT).
    839870
     871{{{
    840872  (defcallback *address-of-inset-rect (result (:struct :rect) r :int delta (:struct :rect))
    841873    (setf (pref result :rect.x) (+ (pref r :rect.x) delta)
     
    843875          (pref result :rect.width) (- (pref r :rect.width) (* 2 delta))
    844876          (pref result :rect.height) (- (pref r :rect.height) (* 2 delta))))
     877}}}
    845878
    846879  Note that this is very similar to what's been (implicitly) supported
     
    903936  This means that (for instance):
    904937
     938{{{
    905939  ? (defvar *listener-process* (current-process))
    906940  *LISTENER-PROCESS*
     
    911945  ;; though of course the underlying OS thread, stacks, etc are unlikely
    912946  ;; to be "equal" in any sense.
     947}}}
    913948
    914949  The current process is sometimes used to mark "ownership" of thread-private
     
    943978  something like:
    944979
     980{{{
    945981  (ns-make-rect 0.0 0.0 500.0 200.0)
     982}}}
    946983
    947984  now needs to do something like:
    948985
     986{{{
    949987  (ns-make-rect (float 0.0 ccl::+cgfloat-zero+) ..)
     988}}}
    950989
    951990  in order to compile and run on both 32-bit and 64-bit platforms.
     
    9811020  For instance:
    9821021
     1022{{{
    9831023? (let* ((start (ccl::rdtsc)))
    9841024    (sleep 1)
    9851025    (- (ccl::rdtsc) start))
    98610261995065244
     1027}}}
    9871028
    9881029  Hmm.  Apparently, the 2.0GHz MacBook I tried that on is actually
     
    10191060 
    10201061
    1021 openmcl 1.1-pre-061231
     1062= openmcl 1.1-pre-061231 =
    10221063- The FASL version changed (old FASL files won't work with this
    10231064  lisp version), as did the version information which tries to