RPL beginner

[DavidM]

Welcome to the world of System RPL programming! There are usually meaningful rewards to be had over standard (User) RPL programs, but the "price to pay" for these rewards is in understanding the more type-specific nature of the commands and the structures provided.

Looking at your program, several things stood out that may need consideration. I'll mention a few here that may help you.

1) Start all System RPL programs with one of the "check" commands. It sets the stage for how the error-handling system in the calculator should attempt to repair the initial stack objects if/when an error occurs in your code. Not all System RPL errors are recoverable, but this is the minimum you should do and it's a good habit to always include this in every System RPL program. In your case, there are no arguments needed by the program. So you should start with CK0NOLASTWD.

2) The GROB you create at the beginning of the program is blank, and you are then displaying it in the blank text display (which was cleared with RECLAIMDISP). This doesn't create a problem, but it serves no particular purpose. I've left that code out of my example since it doesn't contribute to the outcome here. I've also not included the LAMs that aren't used in this example in an effort to reduce distractions.

3) As was pointed out by David Hayden, you may as well just initialize the LAMs you create with their default values. That saves you the trouble of having to assign the initial values later as a separate step.

4) You've set up your indefinite loop to use a keypress as an exit condition. This is a good way to experiment with something like this, and I would suggest extending it one step further: also check for the user pressing the ON (CANCEL) key. This is a natural and intuitive exit case, and requires very little extra code to support it. Also, you don't really need to do anything with the keys which are pressed, so you should probably just ignore them instead of bringing the values to the stack. My example shows one way to do this.

5) Finally, the "check condition" that you are asking about. I've shown one way of doing this in my example, but there's more to it than is obvious in the code. While I believe the code I've provided does what you are suggesting, BINTs are actually not signed values. The reason this works is more a consequence of what happens naturally if you add two unsigned values where the carry would extend through all of the initial (high-order) bits. MINUSONE is defined (in hex notation) as FFFFF. But as a BINT, that actually has a value of (decimal) 1048575 instead of -1. Try the following program to see what I mean:

Code:

::
   CK0NOLASTWD

   "ONE is "

   ONE MINUSONE #>

   ITE "greater" "less" &$

   " than MINUSONE." &$
;

I hope this will give you a good start for further experimentation.

Code:

::
   ( no arguments expected )
   CK0NOLASTWD

   ( setup/clear display )
   ClrDA1IsStat
   RECLAIMDISP
   TURNMENUOFF

   ( allocate locals )
   ZEROZERO
   120 FIFTYTHREE
   ONE
   {
      LAM X1
      LAM Y1
      LAM X2
      LAM Y2
      LAM DY1
   } BIND

   ( clear key buffer )
   FLUSHKEYS
   ATTNFLGCLR

   ( loop until a key is pressed )
   BEGIN
      KEYINBUFFER? ATTN? OR NOT
   WHILE
      ( draw line )
      LAM X1 LAM Y1
      LAM X2 LAM Y2
      LINEON

      ( clear line )
      LAM X1 LAM Y1
      LAM X2 LAM Y2
      LINEOFF

      ( change DY1 value if appropriate )
      LAM Y1 SIXTY #> IT ::
         MINUSONE
         ' LAM DY1 STO
      ;

      ( change Y1 value )
      LAM Y1 LAM DY1 #+
      ' LAM Y1 STO
   REPEAT

   ( clear pressed key )
   FLUSHKEYS
   ATTNFLGCLR

   ( abandon locals )
   ABND

   ( reset display )
   ClrDAsOK
;