Changeset 8465


Ignore:
Timestamp:
Feb 11, 2008, 4:07:20 PM (12 years ago)
Author:
gz
Message:

Update to trunk rev 8464

Location:
branches/gz-working
Files:
1 deleted
10 edited
2 copied

Legend:

Unmodified
Added
Removed
  • branches/gz-working/compiler/X86/x862.lisp

    r8438 r8465  
    49584958         (cstack *x862-cstack*)
    49594959         (vstack *x862-vstack*)
    4960          (target-cstack)
    49614960         (target-vstack)
    49624961         (lastcatch n)
    4963          (i nil)
    49644962         (returning (eq xfer $backend-return))
    49654963         (junk1 nil)
     
    49914989                     (setq numnthrow 0)
    49924990                     (multiple-value-setq (junk1 cstack vstack)
    4993                        (x862-decode-stack (aref *x862-undo-stack* lastcatch))))))
     4991                       (x862-decode-stack (aref *x862-undo-stack* lastcatch)))))
     4992                 (find-last-catch ()
     4993                   (do* ((n n)
     4994                         (reasons *x862-undo-because*))
     4995                        ((= n dest))
     4996                     (declare (fixnum n))
     4997                     (when (eql $undocatch (aref reasons (decf n)))
     4998                       (incf numnthrow)
     4999                       (setq lastcatch n)))))
     5000                           
     5001            (find-last-catch)
     5002            (throw-through-numnthrow-catch-frames)
     5003            (setq n lastcatch)
    49945004            (while (%i> n dest)
    4995               (cond ((eql $undocatch (setq reason (aref *x862-undo-because* (setq n (%i- n 1)))))
    4996                      (pop-temp-frames)
    4997                      (pop-c-frames)
    4998                      (setq numnthrow (%i+ numnthrow 1) lastcatch n))
    4999                     ((eql $undostkblk reason)
    5000                      (throw-through-numnthrow-catch-frames)
     5005              (setq reason (aref *x862-undo-because* (setq n (%i- n 1))))
     5006              (cond ((eql $undostkblk reason)
    50015007                     (incf num-temp-frames))
    50025008                    ((eql $undo-x86-c-frame reason)
    5003                      (throw-through-numnthrow-catch-frames)
    5004                      (incf num-c-frames))))
    5005             (throw-through-numnthrow-catch-frames)
    5006             (setq i lastcatch)
    5007             (while (%i> i dest)
    5008               (let ((reason (aref *x862-undo-because* (setq i (%i- i 1)))))
    5009                 (if (or (eql reason $undospecial)
     5009                     (incf num-c-frames))
     5010                    ((or (eql reason $undospecial)
    50105011                        (eql reason $undointerruptlevel))
    50115012                  (push reason unbind))))
     
    50275028                      (! slide-values))
    50285029                    (! adjust-vsp vdiff)))))
    5029             (setq num-temp-frames 0 num-c-frames 0)
    5030             (while (%i> lastcatch dest)
    5031               (let ((reason (aref *x862-undo-because* (setq lastcatch (%i- lastcatch 1)))))
    5032                 (setq target-cstack (nth-value 1
    5033                                                (x862-decode-stack (aref *x862-undo-stack* lastcatch))))
    5034                 (if (eq reason $undostkblk)
    5035                   (incf num-temp-frames))
    5036                 (if (eq reason $undo-x86-c-frame)
    5037                   (incf num-c-frames))
    5038                 (if (%i> cstack target-cstack)
    5039                   (compiler-bug "bug: adjust foreign stack ??"))
    5040                 ;; else what's going on? $sp-stkcons, for one thing
    5041                 (setq cstack target-cstack)))
    50425030            (pop-temp-frames)
    50435031            (pop-c-frames)))
  • branches/gz-working/compiler/nx-basic.lisp

    r8438 r8465  
    481481        (format stream " (~D references)" nrefs)))
    482482    (princ ", in " stream)
    483     (print-nested-name (reverse (compiler-warning-function-name condition)) stream)
    484     (princ "." stream)))
     483    (print-nested-name (reverse (compiler-warning-function-name condition)) stream)))
    485484
    486485(defun environment-structref-info (name env)
  • branches/gz-working/examples/cocoa/currency-converter/HOWTO.html

    r7920 r8465  
    2020      </h2></div>
    2121
    22     <div class="subtitle">
    23       <img src="HOWTO_files/images/bosco.jpg"
    24            width="48" height="48" border="0" alt=""
    25            border='0'/>
    26     </div>
    27 
    28     <div class="byline">
    29       <p>by mikel evins</p>
    30     </div>
    3122
    3223    <div class="body-text">
     
    3829        Currency Converter</a> example. The most important
    3930        difference between Apple's example and this one is that this
    40         one is implemented in Common Lisp instead of Objective C. It
     31        one is implemented in Common Lisp instead of Objective-C. It
    4132        uses Clozure CL's Objective-C bridge to provide communication
    4233        between the Lisp code that you write and Apple's Cocoa
     
    5041      Apple's InterfaceBuilder application and Clozure CL.</p>
    5142
     43      <p>An observant programmer will look at the code in this example
     44      and say, "well, that's trivial! Why create all those classes and
     45      connections and so forth just to perform a multiplcation?" That
     46      observation is correct: the actual work done by the Currency
     47      Converter application is trivial&mdash;both in the Lisp and the
     48      Objective-C versions. The point of this example (and Apple's) is
     49      not to show you how to perform a multiplication. The point is to
     50      show you how Apple's frameworks implement and support the
     51      Model-View-Controller paradigm, and how you can use that support
     52      to build Cocoa applications. In fact, the work done by the
     53      application is <em>intentionally trivial</em>, to emphasize the
     54      frameworks rather than the particulars of the application.</p>
     55
     56      <p>This HOWTO has the additional purpose of showing you how
     57      Clozure CL makes it possible to do exactly the same thing in
     58      Lisp that you can do with Objective-C, so that you will
     59      understand how to use Lisp with Apple's frameworks.</p>
     60
    5261      <p>The current version of the Clozure CL Objective-C bridge
    5362      includes code that was formerly distributed separately as the
    5463      "Bosco" application framework. Because that framework has been
    5564      integrated with Clozure CL proper, it no longer exists as a
    56       separate project. "Bosco" now names only the decorative rodent
    57       at the top of this page.</p>
     65      separate project.</p>
    5866    </div>
    5967
     
    7179
    7280      <p>In some ways, the Lisp version of the example is simpler
    73       than the Objective C example, but the basic concepts are the
     81      than the Objective-C example, but the basic concepts are the
    7482      same. In particular, the Lisp example follows the same
    7583      <a
  • branches/gz-working/examples/cocoa/currency-converter/HOWTO_files/pages/build_app.html

    r7799 r8465  
    1818      do is to build the application executable into a Cocoa
    1919      application bundle. Apple's tutorial relies on XCode to build
    20       the application from Objective C source files; we will use the
     20      the application from Objective-C source files; we will use the
    2121      Clozure CL IDE to build it from our Lisp source file.</p>
    2222
     
    2525      steps to build the Cocoa application are:</p>
    2626
    27       <ul>
     27      <ol>
    2828        <li><p>Load the application code into the IDE</p></li>
    2929        <li><p>Load the BUILD_APPLICATION feature</p></li>
    3030        <li><p>Run BUILD_APPLICATION with the proper arguments</p></li>
    31       </ul>
     31      </ol>
    3232
    3333      <p>This sequence of steps causes Clozure CL to construct a Cocoa
  • branches/gz-working/examples/cocoa/currency-converter/HOWTO_files/pages/building_ui.html

    r8013 r8465  
    3636      <p>We'll begin by using Apple's InterfaceBuilder application to
    3737        create a nibfile. The nibfile contains
    38         archived versions of the Objective C objects that define the
     38        archived versions of the Objective-C objects that define the
    3939        application's user interface. When you launch an application,
    4040        Mac OS X uses the archived objects in the nibfile to create the
     
    7070        create an application nibfile. InterfaceBuilder creates a new
    7171        application nibfile, but doesn't immediately save it. The
    72         Objective C objects that represent the new application's
     72        Objective-C objects that represent the new application's
    7373        interface appear in a new untitled window:</p>
    7474
     
    9191
    9292      <div class="note">
    93         <p><strong><em>NOTE:</em></strong> Most Objective C application projects use a main
     93        <p><strong><em>NOTE:</em></strong> Most Objective-C application projects use a main
    9494        nibfile called "MainMenu.nib", and if you use XCode to create
    9595        a new application project, it creates a nibfile with that
     
    108108          Clozure CL main nibfile without causing any problems.</p>
    109109
    110         <p>This difference between a Lisp project and an Objective C
     110        <p>This difference between a Lisp project and an Objective-C
    111111        project might be a little confusing at first. Just try to keep
    112112        in mind that whenever Apple's tutorial refers to the
     
    120120<p>Skip straight to the part of Apple's tutorial
    121121called <a href="http://developer.apple.com/documentation/Cocoa/Conceptual/ObjCTutorial/05View/chapter_5_section_1.html#//apple_ref/doc/uid/TP40000863-CH7-SW1">Defining
    122     the View: Building the User Interface</a>. Read
    123   the introduction to
     122the View: Building the User Interface</a>. Read the introduction to
    124123nibfiles, and follow the instructions to create the Currency Converter
    125124interface. (Remember that when the tutorial tells you to open and edit
     
    127126"CurrencyConverter.nib".) When you reach the end of the section
    128127called <a href="http://developer.apple.com/documentation/Cocoa/Conceptual/ObjCTutorial/05View/chapter_5_section_5.html#//apple_ref/doc/uid/TP40000863-CH7-DontLinkElementID_38">Test
    129     the Interface</a>, and move on to the short section afterward
    130   called <a href="http://developer.apple.com/documentation/Cocoa/Conceptual/ObjCTutorial/05View/chapter_5_section_6.html#//apple_ref/doc/uid/TP40000863-CH7-DontLinkElementID_39">What's Next</a>,
    131   you are done creating the interface for your
    132 application. Save your nibfile and continue with the next section.</p>
     128the Interface</a>, and move on to the short section afterward
     129called <a href="http://developer.apple.com/documentation/Cocoa/Conceptual/ObjCTutorial/05View/chapter_5_section_6.html#//apple_ref/doc/uid/TP40000863-CH7-DontLinkElementID_39">What's
     130Next</a>, you are done creating the interface for your
     131application. Save your nibfile and continue with the next section of
     132this HOWTO.</p>
    133133
    134134<div class="section-head">
     
    153153<p>One other thing: if you are using Mac OS X 10.4.x ("Tiger"), you
    154154  will be able to build Cocoa applications only on PPC Macs. The
    155   Clozure CL Objective C support for Intel systems works only on Mac
     155  Clozure CL Objective-C support for Intel systems works only on Mac
    156156  OS X 10.5.x ("Leopard").</p>
    157157
     
    167167  connections in place.</p>
    168168
    169 <p>When you use XCode to write an Objective C application,
    170   InterfaceBuilder can read the Objective C header files and use the
     169<p>When you use XCode to write an Objective-C application,
     170  InterfaceBuilder can read the Objective-C header files and use the
    171171  information in them to create descriptions of the classes in the
    172   Objective C code. When the application is written in Lisp,
     172  Objective-C code. When the application is written in Lisp,
    173173  InterfaceBuilder can't read the class descriptions from the code,
    174174  and so we'll have to manually tell the nibfile about any classes
     
    176176
    177177<p>As you will see in the following sections, we'll use Lisp code to
    178   define two Objective C classes: Converter, and
     178  define two Objective-C classes: Converter, and
    179179  ConverterController. The Converter class implements the method that
    180180  performs the actual currency conversion for our application; the
    181181  ConverterController class provides communication between the user
    182   interface and the Converter object. We need a way to create instaces
    183   of these two classes in the nibfile, so that launching the
    184   application creates these instances and the connections between them
    185   and the rest of the user interface.</p>
     182  interface and the Converter object. We need a way to create
     183  instances of these two classes in the nibfile, so that launching the
     184  application sets up all the objects correctly.</p>
    186185
    187186<div class="section-head">
     
    241240      </div>
    242241
    243 <p>We'll connect each of the "field" outlets to one of the text
    244   fields in the CurrencyConverter UI, and we'll connect the
    245   "converter" outlet to the Converter instance that we created
    246   before. When the application launches, it creates the Converter and
     242<p>We'll connect each of the "field" outlets to one of the text fields
     243  in the CurrencyConverter UI, and we'll connect the "converter"
     244  outlet to the Converter instance that we created before. When the
     245  application launches, it creates the Converter and
    247246  ConverterController instances and establishes the connections that
    248   we specify in the nibfile.</p>
     247  we've specified in the nibfile.</p>
    249248
    250249
     
    264263  outlets.</p>
    265264
    266 <p>Now we'll connect outlets to objects and actions.</p>
     265<p>Now we'll connect outlets and actions to objects.</p>
    267266
    268267<div class="section-head">
  • branches/gz-working/examples/cocoa/currency-converter/HOWTO_files/pages/building_ui_tiger.html

    r8013 r8465  
    5555      section and click the "New" button to create a new
    5656      nibfile. InterfaceBuilder creates a new application nibfile, but
    57       doesn't immediately save it. The Objective C objects that
     57      doesn't immediately save it. The Objective-C objects that
    5858      represent the new application's interface appear in a new
    5959      untitled window:</p>
     
    7272
    7373      <div class="note">
    74         <p><strong><em>NOTE:</em></strong> Most Objective C application projects use a main
     74        <p><strong><em>NOTE:</em></strong> Most Objective-C application projects use a main
    7575        nibfile called "MainMenu.nib", and if you use XCode to create
    7676        a new application project, it creates a nibfile with that
     
    8989          Clozure CL main nibfile without causing any problems.</p>
    9090
    91         <p>This difference between a Lisp project and an Objective C
     91        <p>This difference between a Lisp project and an Objective-C
    9292        project might be a little confusing at first. Just try to keep
    9393        in mind that whenever Apple's tutorial refers to the
     
    183183      </div>
    184184
    185       <p>Now add labels to the text fields, to idenitfy their
     185      <p>Now add labels to the text fields, to identify their
    186186      purposes for the user. For each text field, drag a Label object
    187187      from the palette and drop it next to the field. (Alternatively,
     
    197197      position the text field near the edge of the window, it also
    198198      displays guide lines to help you position the labels near the
    199       text fields. Just drag each text field until the blue guide
    200       lines appear, and release the label.</p>
     199      text fields. Just drag each label until the blue guide lines
     200      appear, then release the label.</p>
    201201
    202202      <p>Now change the text of the labels. Click a label to select
     
    233233     
    234234      <p>The first two text fields accept user input; the last
    235       displays the result of the conversion. We want the first to text
    236       fields to be editable, so users can enter the values to use in
    237       the conversion. We don't want the last field to be editable, but
    238       we do want users to be able to copy text from it.</p>
     235      displays the result of the conversion. We want the first two
     236      text fields to be editable, so users can enter the values to use
     237      in the conversion. We don't want the last field to be editable,
     238      but we do want users to be able to copy text from it.</p>
    239239
    240240      <p>We can control all this behavior using text-field
     
    329329            </div>
    330330          </p>
    331         <p><em>NOTE:</em> This change isn't really enough to get your
     331        <p><strong>NOTE:</strong> This change isn't really enough to get your
    332332        application to display the right name for the Application menu
    333333        when it's launched; the <a href="build_app.html">section</a>
     
    398398      <p>Users generally expect to be able to use the Tab key to move
    399399      from one text field to the next in a dialog
    400       box. InterfaceBuilder enables you to specify the tanning order
     400      box. InterfaceBuilder enables you to specify the tabbing order
    401401      in text fields.</p>
    402402
     
    433433
    434434      <p>The visual elements of your application's user interface are
    435       all ready now. The last thing you must do is create descruptions
     435      all ready now. The last thing you must do is create descriptions
    436436      of any custom classes used by the application when users
    437437      interact with the interface.</p>
     
    439439      <p>When a user clicks the "Convert" button, it should send a
    440440      message to a custom class that causes the conversion to take
    441       place, and the result to be displayed in the "Amount" field. In
    442       order for the application to connect the user interface to
    443       classes that perform these actions, you must add descriptions of
    444       your classes to the nibfile. Fortunately, InterfaceBuilder can
    445       create class descriptions and save them in the nibfile for
    446       you.</p>
     441      place. In order for the application to connect the user
     442      interface to classes that perform these actions, you must add
     443      descriptions of your classes to the nibfile. Fortunately,
     444      InterfaceBuilder can create class descriptions and save them in
     445      the nibfile for you.</p>
    447446
    448447      <div class="section-head">
     
    554553        view of the Inspector window, then click the "connect" button
    555554        to confirm.</p></li>
    556         <li><p>Connect the "ConverterController" instance to text
     555        <li><p>Connect the "ConverterController" instance to the text
    557556        fields. Control-drag from the "ConverterController" instance
    558557        to the "Exchange Rate" field. Select "rateField" in the
    559558        "Outlets" view of the Inspector window and click "connect" to
    560         confirm. Then repeat this process, connecting "dollarField"
    561         to the "Dollars" text field, and "amountField" to the
    562         "Amount" field.</p></li>
     559        confirm. Then repeat this process, connecting "dollarField" to
     560        the "Dollars" text field, and "amountField" to the "Amount"
     561        field.</p></li>
    563562        <li><p>Finally, connect the "ConverterController" to the
    564563        "Converter" instance. Control-drag from the
     
    566565        instance. Select the "converter" outlet in the Inspector
    567566        window and click "connect" to confirm.</p></li>
    568         <li><p></p></li>
    569567      </ol>
    570568
  • branches/gz-working/examples/cocoa/currency-converter/HOWTO_files/pages/conclusion.html

    r7799 r8465  
    1717      CurrencyConverter example in Lisp with Clozure CL. Your own Lisp
    1818      applications are likely to be considerably more complex than the
    19       Currency Converter, which, after all, just does a simpe
     19      Currency Converter, which, after all, just does a simple
    2020      multiplication. You can, however, use exactly the same steps to
    2121      build a much richer and more full-featured Cocoa
     
    2424      <p>A more complex application will still consist of one or more
    2525      nibfiles and one or more Lisp source files. You will still use
    26       the Objective C bridge to define Objective C classes and
     26      the Objective-C bridge to define Objective-C classes and
    2727      methods, and to use Cocoa library features. And you will still
    2828      use BUILD-APPLICATION to turn your source and nibfiles into
     
    3030
    3131      <p>You should now be able to use Clozure CL to accomplish anything
    32       that an Objective C user can accomplish with Cocoa. Good luck!</p>
     32      that an Objective-C user can accomplish with Cocoa. Good luck!</p>
    3333
    3434    <div class="nav">
  • branches/gz-working/examples/cocoa/currency-converter/HOWTO_files/pages/writing_lisp.html

    r7799 r8465  
    1515    <div class="body-text">
    1616      <p>In this section we'll write Lisp code that duplicates the
    17       features provided by the Objective C code in Apple's
     17      features provided by the Objective-C code in Apple's
    1818      tutorial. In Apple's tutorial, the explanation of the Objective
    1919      C code begins with the
     
    2222
    2323      <p>The Lisp code in this section of the HOWTO is considerably
    24       simpler than the corresponding Objective C code, in part
     24      simpler than the corresponding Objective-C code, in part
    2525      because we can ignore the conventions that XCode uses for
    2626      laying out source files. We can just write all our definitions
     
    3737      <pre>(in-package "CCL")</pre>
    3838
    39       <p>Clozure CL's Objective C bridge code is defined in the "CCL"
     39      <p>Clozure CL's Objective-C bridge code is defined in the "CCL"
    4040      package. Usually, when building an application, you'll create a
    4141      package for that application and import the definitions you need
     
    6767      <p>This is an ordinary CLOS class definition, with a couple of
    6868      simple wrinkles. First, the superclass it inherits from is the
    69       NS-OBJECT class in the "NS" package. NS-OBJECT is an Objective C
    70       class, the ancestor of all Objective C objects. This CLOS
    71       definition actually creates a new Objective C class named
     69      NS-OBJECT class in the "NS" package. NS-OBJECT is an Objective-C
     70      class, the ancestor of all Objective-C objects. This CLOS
     71      definition actually creates a new Objective-C class named
    7272      "Converter".</p>
    7373
     
    7979      </pre>   
    8080
    81       <p>The Objective C bridge knows that when the metaclass
     81      <p>The Objective-C bridge knows that when the metaclass
    8282      is <code>ns:+ns-object</code>, it must lay out the class object
    83       in memory as an Objective C class, rather than a normal CLOS
     83      in memory as an Objective-C class, rather than a normal CLOS
    8484      STANDARD-CLASS.</p>
    8585
     
    9393
    9494      <p>This is the method that actually does the currency
    95       conversion. It's very simple&mdash;really, it just multiples
     95      conversion. It's a Lisp method that will be called when the
     96      AppKit sends the Objective-C message "convertCurrency:atRate:"
     97      It's very simple&mdash;really, it just multiples
    9698      <code>currency</code> times <code>rate</code>. Most of the text in the definition is
    97       Objective C bridge code that links the definition to the right
     99      Objective-C bridge code that links the definition to the right
    98100      class with the right argument and return types.</p>
    99101
    100102      <p><code>objc:defmethod</code> is a version of DEFMETHOD that
    101       creates Objective C method definitions.</p>
     103      creates methods that can execute in response to Objective-C
     104      message-sends.</p>
    102105
    103106      <p>The syntax <code>#/convertCurrency:atRate:</code> uses the
    104107      "#/" reader macro to read a symbol with case preserved, so that
    105       you can see in your code the same name that Objective C uses for
     108      you can see in your code the same name that Objective-C uses for
    106109      the method, without worrying about how the name might be
    107       converted between Lisp and Objective C conventions.</p>
    108 
    109       <p>The number of arguments to an Objective C method is the
     110      converted between Lisp and Objective-C conventions.</p>
     111
     112      <p>The number of arguments to an Objective-C method is the
    110113      number of colons in the name, plus one. Each colon indicates an
    111114      argument, and there is always an extra "self" argument that
    112115      refers to the object that receives the message. These are normal
    113       Objective C conventions, but we perhaps need to emphasize the
    114       details, since we are using Lisp code to call the Objective C
     116      Objective-C conventions, but we perhaps need to emphasize the
     117      details, since we are using Lisp code to call the Objective-C
    115118      methods.</p>
    116119
     
    163166      </pre>
    164167     
    165       <p>Once again we use the Objective C bridge to define an
    166       Objective C class. This time, we provide several
     168      <p>Once again we use the Objective-C bridge to define an
     169      Objective-C class. This time, we provide several
    167170      instance-variable definitions in the class, and name accessors
    168171      for each of them explicitly. The <code>:FOREIGN-TYPE</code>
    169       initargs enable us to specify the type of the field in the
    170       foreign (Objective C) class.</p>
     172      initargs enable us to specify the type of each field in the
     173      foreign (Objective-C) class.</p>
    171174
    172175      <p>Each field in the definition of the ConverterController class
    173176      is an outlet that will be used to store a reference to one of
    174       the UI fields that you created in InterfaceBuilder. For
     177      the text fields that you created in InterfaceBuilder. For
    175178      example, <code>amount-field</code> will be connected to the
    176       "Amount" text field.</p> 
     179      "Amount" text field.</p>
    177180
    178181      <p>Why did we spell the name "amount-field" in Lisp code, and
    179182      "amountField" when creating the outlet in InterfaceBuilder?  The
    180       Objective C bridge automatically converts Lisp-style field names
    181       (like "amount-field") to Objective C-style field names (like
     183      Objective-C bridge automatically converts Lisp-style field names
     184      (like "amount-field") to Objective-C-style field names (like
    182185      "amountField"), when handling class definitions.</p>
    183186
     
    209212      conversion. The only significant difference between this
    210213      implementation and Apple's is that the code is written in Lisp
    211       rather than Objective C.</p>
     214      rather than Objective-C.</p>
    212215
    213216      <p>This completes the definition of the CurrencyConverter's
    214       behavior. All that remains is to actually build the cocoa
     217      behavior. All that remains is to actually build the Cocoa
    215218      application. The next section shows how to do that.</p>
    216219
  • branches/gz-working/lib/backtrace.lisp

    r8285 r8465  
    443443                      name
    444444                      (position name names :from-end t))))
    445           (if (and pos (< pos nargs))
     445          (if pos
    446446            (map-entry-value context cfp lfun pc (nth pos indices) unavailable)
    447447            unavailable))
  • branches/gz-working/lisp-kernel/x86-exceptions.c

    r8408 r8465  
    14731473quit_handler(int signum, siginfo_t *info, ExceptionInformation *xp)
    14741474{
     1475#ifdef DARWIN_GS_HACK
     1476  Boolean gs_was_tcr = ensure_gs_pthread();
     1477#endif
    14751478  TCR *tcr = get_tcr(false);
    14761479  area *a;
Note: See TracChangeset for help on using the changeset viewer.