[Chapter Eight][Previous] [Art of Assembly][Randall Hyde]

Art of Assembly: Chapter Eight


8.22 - Sample Program
8.22.1 - EX8.MAK
8.22.2 - Matrix.A
8.22.3 - EX8.ASM
8.22.4 - GETI.ASM
8.22.5 - GetArray.ASM
8.22.6 - XProduct.ASM

8.22 Sample Program


Here is a single program that demonstrates most of the concepts from this chapter. This program consists of several files, including a makefile, that you can assemble and link using the nmake.exe program. This particular sample program computes "cross products" of various functions. The multiplication table you learned in school is a good example of a cross product, so are the truth tables found in Chapter Two of your textbook. This particular program generates cross product tables for addition, subtraction, division, and, optionally, remainder (modulo). In addition to demonstrating several concepts from this chapter, this sample program also demonstrates how to manipulate dynamically allocated arrays. This particular program asks the user to input the matrix size (row and column sizes) and then computes an appropriate set of cross products for that array.


8.22.1 EX8.MAK


The cross product program contains several modules. The following make file assembles all necessary files to ensure a consistent .EXE file.




ex8.exe:ex8.obj geti.obj getarray.obj xproduct.obj matrix.a
	ml ex8.obj geti.obj getarray.obj xproduct.obj

ex8.obj: ex8.asm matrix.a
	ml /c ex8.asm

geti.obj: geti.asm matrix.a
	ml /c geti.asm

getarray.obj: getarray.asm matrix.a
	ml /c getarray.asm


xproduct.obj: xproduct.asm matrix.a
	ml /c xproduct.asm


8.22.2 Matrix.A


MATRIX.A is the header file containing definitions that the cross product program uses. It also contains all the externdef statements for all externally defined routines.




; MATRIX.A
;
; This include file provides the external definitions
; and data type definitions for the matrix sample program
; in Chapter Eight.
;
; Some useful type definitions:

Integer         typedef word
Char            typedef byte

; Some common constants:

Bell            equ     07      ;ASCII code for the bell character.

; A "Dope Vector" is a structure containing information about arrays that
; a program allocates dynamically during program execution.  This particular
; dope vector handles two dimensional arrays.  It uses the following fields:
;
;       TTL-    Points at a zero terminated string containing a description
;               of the data in the array.
;
;       Func-   Pointer to function to compute for this matrix.
;
;       Data-   Pointer to the base address of the array.
;
;       Dim1-   This is a word containing the number of rows in the array.
;
;       Dim2-   This is a word containing the number of elements per row
;               in the array.
;
;       ESize-  Contains the number of bytes per element in the array.

DopeVec         struct
TTL             dword   ?
Func            dword   ?
Data            dword   ?
Dim1            word    ?
Dim2            word    ?
ESize           word    ?
DopeVec         ends

; Some text equates the matrix code commonly uses:

Base            textequ <es:[di]>

byp             textequ <byte ptr>
wp              textequ <word ptr>
dp              textequ <dword ptr>

; Procedure declarations.

InpSeg          segment para public 'input'

                externdef geti:far
                externdef getarray:far

InpSeg          ends


cseg            segment para public 'code'

                externdef CrossProduct:near

cseg            ends


; Variable declarations

dseg            segment para public 'data'

                externdef InputLine:byte

dseg            ends


; Uncomment the following equates if you want to turn on the
; debugging statements or if you want to include the MODULO function.

;debug          equ     0
;DoMOD          equ     0


8.22.3 EX8.ASM


This is the main program. It calls appropriate routines to get the user input, compute the cross product, and print the result.




; Sample program for Chapter Eight.
; Demonstrates the use of many MASM features discussed in Chapter Six
; including label types, constants, segment ordering, procedures, equates,
; address expressions, coercion and type operators, segment prefixes,
; the assume directive, conditional assembly, macros, listing directives,
; separate assembly, and using the UCR Standard Library.
;
; Include the header files for the UCR Standard Library.  Note that the
; "stdlib.a" file defines two segments; MASM will load these segments into
; memory before "dseg" in this program.
;
; The ".nolist" directive tells MASM not to list out all the macros for
; the standard library when producing an assembly listing.  Doing so would
; increase the size of the listing by many tens of pages and would tend to
; obscure the real code in this program.
;
; The ".list" directive turns the listing back on after MASM gets past the
; standard library files.  Note that these two directives (".nolist" and
; ".list") are only active if you produce an assembly listing using MASM's
; "/Fl" command line parameter.


                .nolist
                include    stdlib.a
                includelib stdlib.lib
                .list



; The following statement includes the special header file for this
; particular program.  The header file contains external definitions
; and various data type definitions.

                include matrix.a


; The following two statements allow us to use 80386 instructions
; in the program.  The ".386" directive turns on the 80386 instruction
; set, the "option" directive tells MASM to use 16-bit segments by
; default (when using 80386 instructions, 32-bit segments are the default).
; DOS real mode programs must be written using 16-bit segments.

                .386
                option  segment:use16



dseg            segment para public 'data'

Rows            integer ?       ;Number of rows in matrices
Columns         integer ?       ;Number of columns in matrices


; Input line is an input buffer this code uses to read a string of text
; from the user.  In particular, the GetWholeNumber procedure passes the
; address of InputLine to the GETS routine that reads a line of text
; from the user and places each character into this array.  GETS reads
; a maximum of 127 characters plus the enter key from the user.  It zero
; terminates that string (replacing the ASCII code for the ENTER key with
; a zero).  Therefore, this array needs to be at least 128 bytes long to
; prevent the possibility of buffer overflow.
;
; Note that the GetArray module also uses this array.

InputLine       char    128 dup (0)


; The following two pointers point at arrays of integers.
; This program dynamically allocates storage for the actual array data
; once the user tells the program how big the arrays should be.  The
; Rows and Columns variables above determine the respective sizes of
; these arrays.  After allocating the storage with a call to MALLOC,
; this program stores the pointers to these arrays into the following
; two pointer variables.

RowArray        dword   ?       ;Pointer to Row values
ColArray        dword   ?       ;Pointer to column values.



; ResultArrays is an array of dope vectors(*) to hold the results
; from the matrix operations:
;
; [0]- addition table
; [1]- subtraction table
; [2]- multiplication table
; [3]- division table
;
; [4]- modulo (remainder) table -- if the symbol "DoMOD" is defined.
;
; The equate that follows the ResultArrays declaration computes the number
; of elements in the array.  "$" is the offset into dseg immediately after
; the last byte of ResultArrays.  Subtracting this value from ResultArrays
; computes the number of bytes in ResultArrays.  Dividing this by the size
; of a single dope vector produces the number of elements in the array.
; This is an excellent example of how you can use address expressions in
; an assembly language program.
;
; The IFDEF DoMOD code demonstrates how easy it is to extend this matrix.
; Defining the symbol "DoMOD" adds another entry to this array.  The
; rest of the program adjusts for this new entry automatically.
;
; You can easily add new items to this array of dope vectors.  You will
; need to supply a title and a function to compute the matrice's entries.
; Other than that, however, this program automatically adjusts to any new
; entries you add to the dope vector array.
;
; (*) A "Dope Vector" is a data structure that describes a dynamically
; allocated array.  A typical dope vector contains the maximum value for
; each dimension, a pointer to the array data in memory, and some other
; possible information.  This program also stores a pointer to an array
; title and a pointer to an arithmetic function in the dope vector.

ResultArrays    DopeVec {AddTbl,Addition}, {SubTbl,Subtraction}
                DopeVec {MulTbl,Multiplication}, {DivTbl,Division}

                ifdef   DoMOD
                DopeVec {ModTbl,Modulo}
                endif

; Add any new functions of your own at this point, before the following equate:


RASize          =       ($-ResultArrays) / (sizeof DopeVec)


; Titles for each of the four (five) matrices.

AddTbl          char    "Addition Table",0
SubTbl          char    "Subtraction Table",0
MulTbl          char    "Multiplication Table",0
DivTbl          char    "Division Table",0

                ifdef   DoMOD
ModTbl          char    "Modulo (Remainder) Table",0
                endif

; This would be a good place to put a title for any new array you create.

dseg            ends




; Putting PrintMat inside its own segment demonstrates that you can have
; multiple code segments within a program.  There is no reason we couldn't
; have put "PrintMat" in CSEG other than to demonstrate a far call to a
; different segment.

PrintSeg        segment para public 'PrintSeg'

; PrintMat-     Prints a matrix for the cross product operation.
;
;       On Entry:
;
;               DS must point at DSEG.
;               DS:SI points at the entry in ResultArrays for the
;               array to print.
;
; The output takes the following form:
;
;       Matrix Title
;
;              <- column matrix values ->
;
;       ^      *------------------------*
;       |      |                        |
;       R      |                        |
;       o      | Cross Product Matrix   |
;       w      |       Values           |
;              |                        |
;       V      |                        |
;       a      |                        |
;       l      |                        |
;       u      |                        |
;       e      |                        |
;       s      |                        |
;       |      |                        |
;       v      *------------------------*


PrintMat        proc    far
                assume  ds:dseg


; Note the use of conditional assembly to insert extra debugging statements
; if a special symbol "debug" is defined during assembly.  If such a symbol
; is not defined during assembly, the assembler ignores the following
; statements:

                ifdef   debug
                print
                char    "In PrintMat",cr,lf,0
                endif

; First, print the title of this table.  The TTL field in the dope vector
; contains a pointer to a zero terminated title string.  Load this pointer
; into es:di and call PUTS to print that string.

                putcr
                les     di, [si].DopeVec.TTL
                puts

; Now print the column values.  Note the use of PUTISIZE so that each
; value takes exactly six print positions. The following loop repeats
; once for each element in the Column array (the number of elements in
; the column array is given by the Dim2 field in the dope vector).

                print                           ;Skip spaces to move past the
                char    cr,lf,lf,"       ",0    ; row values.

                mov     dx, [si].DopeVec.Dim2   ;# times to repeat the loop.
                les     di, ColArray            ;Base address of array.
ColValLp:       mov     ax, es:[di]             ;Fetch current array element.
                mov     cx, 6                   ;Print the value using a
                putisize                        ; minimum of six positions.
                add     di, 2                   ;Move on to next element.
                dec     dx                      ;Repeat this loop DIM2 times.
                jne     ColValLp
                putcr                           ;End of column array output
                putcr                           ;Insert a blank line.

; Now output each row of the matrix.  Note that we need to output the
; RowArray value before each row of the matrix.
;
; RowLp is the outer loop that repeats for each row.

                mov     Rows, 0                 ;Repeat for 0..Dim1-1 rows.
RowLp:          les     di, RowArray            ;Output the current RowArray
                mov     bx, Rows                ; value on the left hand side
                add     bx, bx                  ; of the matrix.
                mov     ax, es:[di][bx]         ;ES:DI is base, BX is index.
                mov     cx, 5                   ;Output using five positions.
                putisize
                print
                char    ": ",0

; ColLp is the inner loop that repeats for each item on each row.

                mov     Columns, 0              ;Repeat for 0..Dim2-1 cols.
ColLp:          mov     bx, Rows                ;Compute index into the array
                imul    bx, [si].DopeVec.Dim2   ; index := (Rows*Dim2 +
                add     bx, Columns             ;              columns) * 2
                add     bx, bx

; Note that we only have a pointer to the base address of the array, so we
; have to fetch that pointer and index off it to access the desired array
; element.  This code loads the pointer to the base address of the array into
; the es:di register pair.

                les     di, [si].DopeVec.Data   ;Base address of array.
                mov     ax, es:[di][bx]         ;Get array element

; The functions that compute the values for the array store an 8000h into
; the array element if some sort of error occurs.  Of course, it is possible
; to produce 8000h as an actual result, but giving up a single value to
; trap errors is worthwhile.  The following code checks to see if an error
; occurred during the cross product.  If so, this code prints "  ****",
; otherwise, it prints the actual value.

                cmp     ax, 8000h               ;Check for error value
                jne     GoodOutput
                print
                char    "  ****",0              ;Print this for errors.
                jmp     DoNext

GoodOutput:     mov     cx, 6                   ;Use six print positions.
                putisize                        ;Print a good value.

DoNext:         mov     ax, Columns             ;Move on to next array
                inc     ax                      ; element.
                mov     Columns, ax
                cmp     ax, [si].DopeVec.Dim2   ;See if we're done with
                jb      ColLp                   ; this column.

                putcr                           ;End each column with CR/LF

                mov     ax, Rows                ;Move on to the next row.
                inc     ax
                mov     Rows, ax
                cmp     ax, [si].DopeVec.Dim1   ;Have we finished all the
                jb      RowLp                   ; rows?  Repeat if not done.
                ret
PrintMat        endp
PrintSeg        ends


cseg            segment para public 'code'
                assume  cs:cseg, ds:dseg

;GetWholeNum-   This routine reads a whole number (an integer greater than
;               zero) from the user.  If the user enters an illegal whole
;               number, this procedure makes the user re-enter the data.

GetWholeNum     proc    near
                lesi    InputLine       ;Point es:di at InputLine array.
                gets

                call    Geti            ;Get an integer from the line.
                jc      BadInt          ;Carry set if error reading integer.
                cmp     ax, 0           ;Must have at least one row or column!
                jle     BadInt
                ret

BadInt:         print
                char    Bell
                char    "Illegal integer value, please re-enter",cr,lf,0
                jmp     GetWholeNum
GetWholeNum     endp


; Various routines to call for the cross products we compute.
; On entry, AX contains the first operand, dx contains the second.
; These routines return their result in AX.
; They return AX=8000h if an error occurs.
;
; Note that the CrossProduct function calls these routines indirectly.

addition        proc    far
                add     ax, dx
                jno     AddDone         ;Check for signed arithmetic overflow.
                mov     ax, 8000h       ;Return 8000h if overflow occurs.
AddDone:        ret
addition        endp


subtraction     proc    far
                sub     ax, dx
                jno     SubDone
                mov     ax, 8000h       ;Return 8000h if overflow occurs.
SubDone:        ret
subtraction     endp

multiplication  proc    far
                imul    ax, dx
                jno     MulDone
                mov     ax, 8000h       ;Error if overflow occurs.
MulDone:        ret
multiplication  endp

division        proc    far
                push    cx              ;Preserve registers we destory.

                mov     cx, dx
                cwd
                test    cx, cx          ;See if attempting division by zero.
                je      BadDivide
                idiv    cx

                mov     dx, cx          ;Restore the munged register.
                pop     cx
                ret

BadDivide:      mov     ax, 8000h
                mov     dx, cx
                pop     cx
                ret
division        endp


; The following function computes the remainder if the symbol "DoMOD"
; is defined somewhere prior to this point.

                ifdef   DoMOD
modulo          proc    far
                push    cx

                mov     cx, dx
                cwd
                test    cx, cx          ;See if attempting division by zero.
                je      BadDivide
                idiv    cx
                mov     ax, dx          ;Need to put remainder in AX.
                mov     dx, cx          ;Restore the munged registers.
                pop     cx
                ret

BadMod:         mov     ax, 8000h
                mov     dx, cx
                pop     cx
                ret
modulo          endp
                endif

; If you decide to extend the ResultArrays dope vector array, this is a good
; place to define the function for those new arrays.


; The main program that reads the data from the user, calls the appropriate
; routines, and then prints the results.

Main            proc
                mov     ax, dseg
                mov     ds, ax
                mov     es, ax
                meminit

; Prompt the user to enter the number of rows and columns:

GetRows:        print
                byte    "Enter the number of rows for the matrix:",0

                call    GetWholeNum
                mov     Rows, ax

; Okay, read each of the row values from the user:

                print
                char    "Enter values for the row (vertical) array",cr,lf,0

; Malloc allocates the number of bytes specified in the CX register.
; AX contains the number of array elements we want;  multiply this value
; by two since we want an array of words.  On return from malloc, es:di
; points at the array allocated on the "heap".  Save away this pointer in
; the "RowArray" variable.
;
; Note the use of the "wp" symbol. This is an equate to "word ptr" appearing
; in the "matrix.a" include file.  Also note the use of the address expression
; "RowArray+2" to access the segment portion of the double word pointer.

                mov     cx, ax
                shl     cx, 1
                malloc
                mov     wp RowArray, di
                mov     wp RowArray+2, es

; Okay, call "GetArray" to read "ax" input values from the user.
; GetArray expects the number of values to read in AX and a pointer
; to the base address of the array in es:di.

                print
                char    "Enter row data:",0

                mov     ax, Rows        ;# of values to read.
                call    GetArray        ;ES:DI still points at array.


; Okay, time to repeat this for the column (horizontal) array.

GetCols:        print
                byte    "Enter the number of columns for the matrix:",0

                call    GetWholeNum     ;Get # of columns from the user.
                mov     Columns, ax     ;Save away number of columns.


; Okay, read each of the column values from the user:

                print
                char    "Enter values for the column (horz.) array",cr,lf,0

; Malloc allocates the number of bytes specified in the CX register.
; AX contains the number of array elements we want;  multiply this value
; by two since we want an array of words.  On return from malloc, es:di
; points at the array allocated on the "heap".  Save away this pointer in
; the "RowArray" variable.

                mov     cx, ax                  ;Convert # Columns to # bytes
                shl     cx, 1                   ; by multiply by two.
                malloc                          ;Get the memory.
                mov     wp ColArray, di         ;Save pointer to the
                mov     wp ColArray+2, es       ;columns vector (array).

; Okay, call "GetArray" to read "ax" input values from the user.
; GetArray expects the number of values to read in AX and a pointer
; to the base address of the array in es:di.

                print
                char    "Enter Column data:",0

                mov     ax, Columns             ;# of values to read.
                call    GetArray                ;ES:DI points at column array.

; Okay, initialize the matrices that will hold the cross products.
; Generate RASize copies of the following code.
; The "repeat" macro repeats the statements between the "repeat" and the "endm"
; directives RASize times.  Note the use of the Item symbol to automatically
; generate different indexes for each repetition of the following code.
; The "Item = Item+1" statement ensures that Item will take on the values
; 0, 1, 2, ..., RASize on each repetition of this loop.
;
; Remember, the "repeat..endm" macro copies the statements multiple times
; within the source file, it does not execute a "repeat..until" loop at
; run time.  That is, the following macro is equivalent to making "RASize"
; copies of the code, substituting different values for Item for each
; copy.
;
; The nice thing about this code is that it automatically generates the
; proper amount of initialization code, regardless of the number of items
; placed in the ResultArrays array.


Item            =       0

                repeat  RASize

                mov     cx, Columns     ;Compute the size, in bytes,
                imul    cx, Rows        ; of the matrix and allocate
                add     cx, cx          ; sufficient storage for the
                malloc                  ; array.

                mov     wp ResultArrays[Item * (sizeof DopeVec)].Data, di
                mov     wp ResultArrays[Item * (sizeof DopeVec)].Data+2, es

                mov     ax, Rows
                mov     ResultArrays[Item * (sizeof DopeVec)].Dim1, ax

                mov     ax, Columns
                mov     ResultArrays[Item * (sizeof DopeVec)].Dim2, ax

                mov     ResultArrays[Item * (sizeof DopeVec)].ESize, 2

Item            =       Item+1
                endm


; Okay, we've got the input values from the user,
; now let's compute the addition, subtraction, multiplication,
; and division tables.  Once again, a macro reduces the amount of
; typing we need to do at this point as well as automatically handling
; however many items are present in the ResultArrays array.

element         =       0

                repeat  RASize
                lfs     bp, RowArray            ;Pointer to row data.
                lgs     bx, ColArray            ;Pointer to column data.

                lea     cx, ResultArrays[element * (sizeof DopeVec)]
                call    CrossProduct

element         =       element+1
                endm


; Okay, print the arrays down here.  Once again, note the use of the
; repeat..endm macro to save typing and automatically handle additions
; to the ResultArrays array.


Item            =       0

                repeat  RASize
                mov     si, offset ResultArrays[item * (sizeof DopeVec)]
                call    PrintMat
Item            =       Item+1
                endm


; Technically, we don't have to free up the storage malloc'd for each
; of the arrays since the program is about to quit.  However, it's a
; good idea to get used to freeing up all your storage when you're done
; with it.  For example, were you to add code later at the end of this
; program, you would have that extra memory available to that new code.

                les     di, ColArray
                free
                les     di, RowArray
                free

Item            =       0
                repeat  RASize
                les     di, ResultArrays[Item * (sizeof DopeVec)].Data
                free
Item            =       Item+1
                endm


Quit:           ExitPgm                 ;DOS macro to quit program.
Main            endp

cseg            ends

sseg            segment para stack 'stack'
stk             byte    1024 dup ("stack   ")
sseg            ends

zzzzzzseg       segment para public 'zzzzzz'
LastBytes       byte    16 dup (?)
zzzzzzseg       ends
                end     Main


8.22.4 GETI.ASM


GETI.ASM contains a routine (geti) that reads an integer value from the user.




; GETI.ASM
;
; This module contains the integer input routine for the matrix
; example in Chapter Eight.

                .nolist
                include stdlib.a
                .list

                include matrix.a

InpSeg          segment para public 'input'

; Geti- On entry, es:di points at a string of characters.
;       This routine skips any leading spaces and comma characters and then
;       tests the first (non-space/comma) character to see if it is a digit.
;       If not, this routine returns the carry flag set denoting an error.
;       If the first character is a digit, then this routine calls the
;       standard library routine "atoi2" to convert the value to an integer.
;       It then ensures that the number ends with a space, comma, or zero
;       byte.
;
;       Returns carry clear and value in AX if no error.
;       Returns carry set if an error occurs.
;
;       This routine leaves ES:DI pointing at the character it fails on when
;       converting the string to an integer.  If the conversion occurs without
;       an error, the ES:DI points at a space, comma, or zero terminating byte.


geti            proc    far

                ifdef   debug
                print
                char    "Inside GETI",cr,lf,0
                endif

; First, skip over any leading spaces or commas.
; Note the use of the "byp" symbol to save having to type "byte ptr".
; BYP is a text equate appearing in the macros.a file.
; A "byte ptr" coercion operator is required here because MASM cannot
; determine the size of the memory operand (byte, word, dword, etc)
; from the operands.  I.e., "es:[di]" and ' ' could be any of these
; three sizes.
;
; Also note a cute little trick here; by decrementing di before entering
; the loop and then immediately incrementing di, we can increment di before
; testing the character in the body of the loop.  This makes the loop
; slightly more efficient and a lot more elegant.

                dec     di
SkipSpcs:       inc     di
                cmp     byp es:[di], ' '
                je      SkipSpcs
                cmp     byp es:[di], ','
                je      SkipSpcs

; See if the first non-space/comma character is a decimal digit:

                mov     al, es:[di]
                cmp     al, '-'          ;Minus sign is also legal in integers.
                jne     TryDigit
                mov     al, es:[di+1]    ;Get next char, if "-"

TryDigit:       isdigit
                jne     BadGeti         ;Jump if not a digit.

; Okay, convert the characters that follow to an integer:

ConvertNum:     atoi2                   ;Leaves integer in AX
                jc      BadGeti         ;Bomb if illegal conversion.

; Make sure this number ends with a reasonable character (space, comma,
; or a zero byte):

                cmp     byp es:[di], ' '
                je      GoodGeti
                cmp     byp es:[di], ','
                je      GoodGeti
                cmp     byp es:[di], 0
                je      GoodGeti

                ifdef   debug
                print
                char    "GETI: Failed because number did not end with "
                char    "a space, comma, or zero byte",cr,lf,0
                endif

BadGeti:        stc                     ;Return an error condition.
                ret

GoodGeti:       clc                     ;Return no error and an integer in AX
                ret
geti            endp

InpSeg          ends
                end


8.22.5 GetArray.ASM


GetArray.ASM contains the GetArray input routine. This reads the data for the array from the user to produce the cross products. Note that GetArray reads the data for a single dimension array (or one row in a multidimensional array). The cross product program reads two such vectors: one for the column values and one for the row values in the cross product. Note: This routine uses subroutines from the UCR Standard Library that appear in the next chapter.




; GETARRAY.ASM
;
; This module contains the GetArray input routine.  This routine reads a
; set of values for a row of some array.

                .386
                option  segment:use16

                .nolist
                include stdlib.a
                .list

                include matrix.a

; Some local variables for this module:

localdseg       segment para public 'LclData'

NumElements     word    ?
ArrayPtr        dword   ?

Localdseg       ends


InpSeg          segment para public 'input'
                assume  ds:Localdseg

; GetArray-     Read a set of numbers and store them into an array.
;
;       On Entry:
;
;               es:di points at the base address of the array.
;               ax contains the number of elements in the array.
;
;               This routine reads the specified number of array elements
;               from the user and stores them into the array.  If there
;               is an input error of some sort, then this routine makes
;               the user reenter the data.

GetArray        proc    far
                pusha                   ;Preserve all the registers
                push    ds              ; that this code modifies
                push    es
                push    fs

                ifdef   debug
                print
                char    "Inside GetArray, # of input values =",0
                puti
                putcr
                endif

                mov     cx, Localdseg           ;Point ds at our local
                mov     ds, cx                  ; data segment.

                mov     wp ArrayPtr, di         ;Save in case we have an
                mov     wp ArrayPtr+2, es       ; error during input.
                mov     NumElements, ax

; The following loop reads a line of text from the user containing some
; number of integer values.  This loop repeats if the user enters an illegal
; value on the input line.
;
; Note: LESI is a macro from the stdlib.a include file.  It loads ES:DI
; with the address of its operand (as opposed to les di, InputLine that would
; load ES:DI with the dword value at address InputLine).

RetryLp:        lesi    InputLine       ;Read input line from user.
                gets
                mov     cx, NumElements ;# of values to read.
                lfs     si, ArrayPtr    ;Store input values here.

; This inner loop reads "ax" integers from the input line.  If there is
; an error, it transfers control to RetryLp above.

ReadEachItem:   call    geti            ;Read next available value.
                jc      BadGA
                mov     fs:[si], ax     ;Save away in array.
                add     si, 2           ;Move on to next element.
                loop    ReadEachItem    ;Repeat for each element.

                pop     fs              ;Restore the saved registers
                pop     es              ; from the stack before
                pop     ds              ; returning.
                popa
                ret

; If an error occurs, make the user re-enter the data for the entire
; row:

BadGA:          print
                char    "Illegal integer value(s).",cr,lf
                char    "Re-enter data:",0
                jmp     RetryLp
getArray        endp

InpSeg          ends
                end


8.22.6 XProduct.ASM


This file contains the code that computes the actual cross-product.




; XProduct.ASM-
;
;       This file contains the cross-product module.

                .386
                option   segment:use16

                .nolist
                include     stdlib.a
                includelib  stdlib.lib
                .list

                include  matrix.a

; Local variables for this module.

dseg            segment para public 'data'
DV              dword   ?
RowNdx          integer ?
ColNdx          integer ?
RowCntr         integer ?
ColCntr         integer ?
dseg            ends


cseg            segment para public 'code'
                assume  ds:dseg

; CrossProduct- Computes the cartesian product of two vectors.
;
;       On entry:
;
;       FS:BP-  Points at the row matrix.
;       GS:BX-  Points at the column matrix.
;       DS:CX-  Points at the dope vector for the destination.
;
;       This code assume ds points at dseg.
;       This routine only preserves the segment registers.

RowMat          textequ <fs:[bp]>
ColMat          textequ <gs:[bx]>
DVP             textequ <ds:[bx].DopeVec>

CrossProduct    proc    near

                ifdef   debug
                print
                char    "Entering CrossProduct routine",cr,lf,0
                endif

                xchg    bx, cx          ;Get dope vector pointer
                mov     ax, DVP.Dim1    ;Put Dim1 and Dim2 values
                mov     RowCntr, ax     ; where they are easy to access.
                mov     ax, DVP.Dim2
                mov     ColCntr, ax
                xchg    bx, cx


; Okay, do the cross product operation.  This is defined as follows:
;
;       for RowNdx := 0 to NumRows-1 do
;           for ColNdx := 0 to NumCols-1 do
;               Result[RowNdx, ColNdx] = Row[RowNdx] op Col[ColNdx];

                mov     RowNdx, -1      ;Really starts at zero.
OutsideLp:      add     RowNdx, 1
                mov     ax, RowNdx
                cmp     ax, RowCntr
                jge     Done

                mov     ColNdx, -1      ;Really starts at zero.
InsideLp:       add     ColNdx, 1
                mov     ax, ColNdx
                cmp     ax, ColCntr
                jge     OutSideLp

                mov     di, RowNdx
                add     di, di
                mov     ax, RowMat[di]

                mov     di, ColNdx
                add     di, di
                mov     dx, ColMat[di]

                push    bx              ;Save pointer to column matrix.
                mov     bx, cx          ;Put ptr to dope vector where we can
                                        ; use it.

                call    DVP.Func        ;Compute result for this guy.

                mov     di, RowNdx      ;Index into array is
                imul    di, DVP.Dim2    ; (RowNdx*Dim2 + ColNdx) * ElementSize
                add     di, ColNdx
                imul    di, DVP.ESize

                les     bx, DVP.Data    ;Get base address of array.
                mov     es:[bx][di], ax ;Save away result.

                pop     bx              ;Restore ptr to column array.
                jmp     InsideLp

Done:           ret
CrossProduct    endp
cseg            ends
                end
8.22 - Sample Program
8.22.1 - EX8.MAK
8.22.2 - Matrix.A
8.22.3 - EX8.ASM
8.22.4 - GETI.ASM
8.22.5 - GetArray.ASM
8.22.6 - XProduct.ASM


Art of Assembly: Chapter Eight - 26 SEP 1996

[Chapter Eight][Previous] [Art of Assembly][Randall Hyde]



Number of Web Site Hits since Jan 1, 2000: