home *** CD-ROM | disk | FTP | other *** search
/ ftp.whtech.com / ftp.whtech.com.tar / ftp.whtech.com / Geneve / 9640news / CAT14 / FLTNGPN.ARK < prev    next >
Text File  |  2006-10-19  |  9KB  |  316 lines
  1. ?
  2.   **************************************
  3.   *                                    *
  4.   *         ASSEMBLY LANGUAGE          *
  5.   *                                    *
  6.   *        FLOATING-POINT MATH         *
  7.   *                                    *
  8.   *         by Steve Langguth          *
  9.   *      Ozark 99'er Users Group       *
  10.   *                                    *
  11.   **************************************
  12.  
  13.  
  14.       Recently I was writing an assembly
  15.  language program and all of a sudden
  16.  realized that I needed to use decimal
  17.  numbers.  "Time to learn about floating
  18.  point math in assembly language," I
  19.  said to myself.  But as usual with A/L
  20.  it was easier said than done.  I knew
  21.  that I needed to use various "GPLLNK"
  22.  and "XMLLNK" routines, but how they
  23.  were used I learned by trial and error,
  24.  luck, and by using "Explorer"
  25.  frequently.  The program below is
  26.  worthless except that it demonstrates
  27.  some of the techniques I "created" for
  28.  working with floating point numbers.
  29.  The program prints two numbers on the
  30.  screen, converts them into FP, adds
  31.  them together, converts the FP result
  32.  into a string and displays the result.
  33.  The explanation follows the program.
  34.  
  35.  *
  36.         DEF  START
  37.  *
  38.         REF  VSBW,VMBW,KSCAN
  39.         REF  XMLLNK,GPLLNK
  40.  *
  41.  FAC    EQU  >834A       F/P ACCUM
  42.  ARG    EQU  >835C       ARGUMENT
  43.  STRNG  EQU  >8356       FAC+12
  44.  KEYADR EQU  >8374
  45.  KEYVAL EQU  >8375
  46.  *
  47.  SPBR   BYTE >20
  48.  *
  49.  ONE    TEXT '11.1111'
  50.  TWO    TEXT '2.222'
  51.  LINE   TEXT '-------'
  52.  *
  53.         EVEN
  54.  *
  55.  MYREG  BSS  >20
  56.  ONEFP  BSS  8
  57.  SUM    BSS  16
  58.  *
  59.  START  LWPI MYREG
  60.  *
  61.         LI   R0,>008A
  62.         LI   R1,ONE
  63.         LI   R2,7
  64.         BLWP @VMBW       DISPLAY "ONE"
  65.  *
  66.         BL   @WAIT       WAIT FOR SPACE
  67.  *
  68.         LI   R0,>00C9
  69.         LI   R1,>2B00
  70.         BLWP @VSBW       DISPLAY "+"
  71.  *
  72.         BL   @WAIT       WAIT FOR SPACE
  73.  *
  74.         LI   R0,>00CB
  75.         LI   R1,TWO
  76.         LI   R2,5
  77.         BLWP @VMBW       DISPLAY "TWO"
  78.  *
  79.         BL   @WAIT       WAIT FOR SPACE
  80.  *
  81.         LI   R0,>010A
  82.         LI   R1,LINE
  83.         LI   R2,7
  84.         BLWP @VMBW       DISPLAY "LINE"
  85.  *
  86.         LI   R0,>008A
  87.         MOV  R0,@STRNG   PUT ADDRESS OF
  88.  *                       "ONE" IN FAC+12
  89.         BLWP @XMLLNK
  90.         DATA >1000       F/P NUMBER NOW
  91.  *                       IN FAC
  92.  *
  93.         LI   R1,FAC
  94.         LI   R2,ONEFP
  95.         BL   @TRANS      MOVE RESULT TO
  96.  *                       "ONEFP"
  97.  *
  98.         LI   R0,>00CB
  99.         MOV  R0,@STRNG   PUT ADDRESS OF
  100.  *                       "TWO" IN FAC+12
  101.         BLWP @XMLLNK
  102.         DATA >1000       F/P # IN FAC
  103.  *
  104.         LI   R1,ONEFP
  105.         LI   R2,ARG
  106.         BL   @TRANS      "TWOFP" IN FAC,
  107.  *                       "ONEFP" IN ARG
  108.  *
  109.         BLWP @XMLLNK
  110.         DATA >0600       (ONEFP + TWOFP)
  111.  *                       RESULT IN FAC
  112.  *
  113.         CLR  R0
  114.         MOVB R0,@>8355
  115.  *
  116.         CLR  R1
  117.         MOVB R1,@>837C
  118.         BLWP @GPLLNK
  119.         DATA >0014       CONVERT FP SUM
  120.  *                       TO ASCII STRING
  121.  *
  122.         CLR  R1
  123.         MOVB @>8355,R1
  124.         SWPB R1
  125.         AI   R1,>8300    R1 = ADDR. OF
  126.  *                       ASCII STRING
  127.         LI   R2,SUM
  128.  *
  129.         CLR  R3
  130.         MOVB @>8356,R3
  131.         SWPB R3          R3 = # OF BYTES
  132.  *                       IN NEW STRING
  133.  *
  134.  X      MOVB *R1+,*R2+
  135.         DEC  R3
  136.         MOV  R3,R3
  137.         JNE  X           MOVE STRING
  138.  *                       INTO "SUM"
  139.  *
  140.         CB   @SUM,@SPBR  IS FIRST CHAR
  141.  *                       A "SPACE" ?
  142.         JNE  Y
  143.  *
  144.         LI   R0,>014A
  145.         LI   R1,SUM+1
  146.         LI   R2,7
  147.         BLWP @VMBW       DISPLAY "SUM"
  148.  *                       WITHOUT SPACE
  149.         JMP  LOOP
  150.  *
  151.  Y      LI   R0,>014A
  152.         LI   R1,SUM
  153.         LI   R2,8
  154.         BLWP @VMBW       DISPLAY "SUM"
  155.  *
  156.  LOOP   LIMI 2
  157.         JMP  LOOP
  158.  *
  159.  WAIT   CLR  R0
  160.         MOV  R0,@KEYADR
  161.  A      BLWP @KSCAN
  162.         CB   @KEYVAL,@SPBR
  163.         JNE  A
  164.  *
  165.         LI   R0,10000
  166.  B      DEC  R0
  167.         CI   R0,0
  168.         JNE  B
  169.  *
  170.         RT
  171.  *
  172.  TRANS  CLR  R3
  173.  C      MOV  *R1+,*R2+
  174.         CI   R3,3
  175.         JEQ  D
  176.         INC  R3
  177.         JMP  C
  178.  *
  179.  D      RT
  180.  *
  181.         END
  182.  
  183.  
  184.       The first two lines of source code
  185.  define the name of the program and
  186.  reference the utilities to be used.
  187.  The next group of 5 lines "name"
  188.  various addresses that will be used
  189.  later.  The 4 lines that follow label
  190.  certain data we will also use later.
  191.  The EVEN statement is used to make sure
  192.  we begin on an even address after our
  193.  TEXT statements.  Following the EVEN
  194.  statement, we set up 3 buffers.
  195.       The line labelled START is the
  196.  beginning of the actual program
  197.  statements.  First we tell the computer
  198.  to use the MYREG buffer for the
  199.  workspace registers, using the LWPI
  200.  command.  The next group of 4 lines
  201.  displays the text string labelled ONE
  202.  at screen address >008A.  Then, we
  203.  branch to a subroutine that waits for
  204.  the space bar to be pressed.  The same
  205.  sequence of commands is used to display
  206.  the "+" sign, the text string TWO, and
  207.  the text string LINE.
  208.       After the "line" has been drawn,
  209.  we actually begin to use the floating
  210.  point routines.  The first routine
  211.  converts a text string into a floating
  212.  point number.  You can read the details
  213.  about how this routine works on pages
  214.  257-262 of the E/A manual.  First, we
  215.  put the address of the string we wish
  216.  to convert into R0, and then MOVe it to
  217.  address FAC+12 (which we named STRNG
  218.  earlier).  The next two lines tell the
  219.  computer we want to use the XMLLNK
  220.  routine to convert a string to a FP
  221.  number.  The result of this conversion
  222.  is put at address FAC (>834A).  Each
  223.  floating point number is 8 bytes long,
  224.  and is in a form known as Radix 100
  225.  notation.  The details of this form of
  226.  notation are on page 279 of the
  227.  manual.
  228.       Next, we use a little routine I
  229.  came up with to easily move FP numbers
  230.  around.  Since each FP number is 8
  231.  bytes long, we can't use a simple MOV
  232.  command.  Instead we use the TRANS
  233.  routine found near the end of the
  234.  program.  This routine moves 8 bytes (4
  235.  words) of data from the address put in
  236.  R1 to address put in R2.  The routine
  237.  uses Workspace Register Indirect Auto
  238.  Increment Addressing Mode. (See page 58
  239.  of the E/A manual.) We put the address
  240.  FAC into R1, ONEFP into R2, and then
  241.  branch and link to the TRANS
  242.  subroutine.  This moves the FP number
  243.  (11.1111) from FAC into the ONEFP
  244.  buffer.
  245.       After that, we convert TWO in the
  246.  same way, but this time we leave the
  247.  result in the FAC.  Then, we move ONEFP
  248.  into ARG (using the TRANS subroutine),
  249.  and call the XMLLNK routine that adds
  250.  the two FP numbers together.
  251.       Now we must convert our sum back
  252.  into a form that can be displayed on
  253.  the screen.  To do this, we need to use
  254.  a GPLLNK routine. (The details of using
  255.  these routines are found on page 251 of
  256.  the E/A manual.) First we set >8355 to
  257.  0.  This means our string will be in TI
  258.  Basic format.  I haven't been able to
  259.  find a description of what that format
  260.  is, but I was able to get this to work
  261.  using Basic format and NOT using "Fixed
  262.  Mode".  Next we clear the status
  263.  register and call the GPLLNK routine to
  264.  do the conversion.  After the
  265.  conversion, the byte at >8355 is added
  266.  to >8300 to determine the address of
  267.  our new string.  This address is put in
  268.  R1.  R2 is loaded with the address of
  269.  our buffer to hold the result.  Then,
  270.  we use a routine similar to our TRANS
  271.  routine to move the string to the SUM
  272.  buffer.  This time, however, we use the
  273.  value at >8356 to determine how many
  274.  bytes to move.
  275.       After the string is moved, we
  276.  display it on the screen.  Sometimes,
  277.  the string created by the conversion
  278.  routine begins with a space, and
  279.  sometimes not.  I assume this is to
  280.  leave room for a minus sign if one is
  281.  needed, but it complicates the
  282.  displaying of our result.  So, we check
  283.  to see if the first character of the
  284.  string is a space.  If so, we jump to a
  285.  set of statements that puts the result
  286.  at the correct place on the screen.  If
  287.  the first character is a space, we skip
  288.  that character and print the next 7
  289.  characters where they belong.
  290.       Finally, we enter a loop that
  291.  allows us to end by pressing the "QUIT"
  292.  button.  The source code after the LOOP
  293.  is the WAIT subroutine that waits for
  294.  the space bar to be pressed, then goes
  295.  into a delay loop before returning to
  296.  the main program.  This keeps the
  297.  program from jumping through more than
  298.  one step if you hold the bar down just
  299.  a little too long.  After the WAIT
  300.  routine is the TRANS subroutine
  301.  described above.
  302.       I realize this description is not
  303.  too detailed, but the best way to
  304.  really understand what is going on is
  305.  by experimenting.  Try changing the
  306.  numbers, or subtracting or multiplying
  307.  them instead of adding.  With a little
  308.  practice, you too can become an
  309.  "expert" at using floating point
  310.  numbers in 99/4A Assembly Language.
  311.  
  312.  
  313. Download complete.  Turn off Capture File.
  314.  
  315.  
  316.