Chapter 10 Part 1

Standard Statements and Functions

DIM

The DIM statement is used to declare and define variables for use in the program. If a variable is used that has not been DIMensioned, it has a default type of LONG unless the name ends in “$” or “_Str” in which case the default is type STRING[32]. If the -d command line option is invoked, there are no default data types and each variable must be DIMensioned.

The DIM statement may appear anywhere in a main program, but must appear before being referenced. The DIM statement may not appear in a subroutine. The general syntax of the DIM statement is as follows:

DIM VarName{(ArraySize)}:DataType {modifier modifier}

The syntax of the DIM statement is slightly different for string variables and is as follows:

DIM StringNam{(ArraySize)}:STRING[StringSize]{modifier modifier}

The DIM keyword is followed by the variable name. The optional array size is then stated (in parentheses). There may be 1, 2, or 3 diminsions for arrays. A comma separates these diminsions. This is followed by a mandatory “:” or “AS”. The data type is then specified. (“DIM X:LONG” or “DIM X as LONG”). Next the optional modifiers are declared. The valid data types are BOOLEAN or LOGICAL, BYTE or CHAR, SHORT, INT, or WORD (16 bit integer), LONG or INTEGER (32 bit integer), FLOAT or REAL (floating point) , FILE, and STRING (also OBJECT and FORM for GUI versions). The valid modifiers are EXTERNAL, GLOBAL, ADDRESS or POINTER, and VECTOR. The BOOLEAN data type is eight bits in length and is capable of two states: TRUE and FALSE. The BYTE data type is an 8-bit integer. The SHORT data type is a 16-bit integer, while the LONG type is a 32-bit integer. The EXTERNAL modifier means the actual variable is in another module so no space will be allocated for it. The GLOBAL modifier makes the variable known to other modules. The ADDRESS modifier causes the variable to become an ADDRESS Pointer of the data type specified (see section on Address Pointers). The VECTOR modifier causes the variable to be assigned to a special 12-byte vector. A VECTOR (like a pointer) cannot be used until an address is assigned to it. Once an address is assigned, (SETVEC VarName=Addr) the VECTOR behaves just as an ordinary variable and requires no special syntax.

Now for some examples:

DIM Test(4) AS INTEGER \ creates an integer array of 4 elements called Test
DIM Cat(2,2) AS STRING * 25\ creates a two diminsion string array
DIM Ptr:INTEGER POINTER \ creates a pointer of data type integer
DIM Name:STRING[30] \ creates a string variable of up to 30 bytes named Name
DIM Dog:SHORT EXTERNAL \ this one allocates no storage
DIM Frog:LONG GLOBAL \ this one is known to all other linked modules
“DIM STRVAR:STRING[32]" or "DIM STRVAR as STRING * 32"

TYPE

The TYPE statement allows the user to define custom data types for the application at hand. Once a TYPE statement defines a data type it may be DIMinsioned like a standard data type.

The TYPE statement may not appear inside a function or subroutine.

The general syntax of the TYPE statement is as follows:

TYPE TypeName=FieldName{Array}:DataType{;FieldName{Array}:DataType...}

The TypeName then becomes a new user defined data type. The new data type is then DIMensioned like any other variable and the resultant variable is accessed by the variable name followed by a period followed by the field name. The data types used within the TYPE statement must be of the standard types described above in the DIM section (not other user defined types).

The fields within the TYPE may be simple or arrays and the variables later DIMensioned of data type TypeName may be simple or arrays. An example of a TYPE declaration, DIMensioning of the resultant data type, and the use of the variable follow:

TYPE StockItem=PartNum:INTEGER;OnHand:INTEGER;Cost:INTEGER DIM StockList(100):StockItem \ create an array of 100 StockItems DIM Temp:INTEGER REGISTER REM A loop to initialize all 100 elements of the array to zero (0)

FOR Temp=1 to 100
   StockList(Temp).StockItem=0
   StockList(Temp).OnHand=0
   StockList(Temp).Cost=0
NEXT Temp

See also #STRUCT and #ENDSTRUCT

The TYPE statement may also be expressed as a group, which is terminated by END TYPE or ENDTYPE.

TYPE StockItem
   PartNum AS INTEGER
   OnHand AS INTEGER
   COST AS INTEGER
END TYPE

BEEP

The BEEP statement causes an audible beep. There are no arguments to this statement.

RANDOMIZE

The RANDOMIZE statement is used to change seed of the random number generator.

RANDOMIZE <IntVar>

If IntVar is ommited, the timer is used as the seed.

PROGRAM

The PROGRAM Statement is used to tell the compiler where the code section of the program is to begin. It is almost never required because the compiler “knows” when the code is to begin EXCEPT if the first line of code is C or Assembler. If the first line of code is C, C++ or Assembler, use the program statement immediately preceding the first line of code.

HEXOUT

This statement allows control over the output of the Hex$() function. In the examples below, the compiler checks only the first letter. The default is Motorola ($ffff).

HEXOUT motorola (preceeds hex value with “s”)
HEXOUT intel (preceeds hex value with “0” and adds “h” at end)
HEXOUT c (preceeds hex value with “0x”)
HEXOUT none (adds nothing)

GOTO, GOSUB, RETURN

The GOTO and GOSUB Statements are used in conjunction with labels to transfer program control. Both statements unconditionally transfer control to the designated label but the GOSUB statement saves the address of the next sequential statement on a stack so that the RETURN statement (in the called subroutine) causes control to resume where it left of when the GOSUB occurred. Structured programming techniques do not encourage the use of the GOTO statement, but rather prefer the IF/ ENDIF, WHILE/ENDWHILE and PROCEDURE constructs as well as others. The following is an example of the use of the GOTO statement:

Label1 PRINT “This will print forever”
GOTO Label1

The GOSUB (GO SUBROUTINE) statement is used when it is required for the program to resume where it left off after the called subroutine is finished and executes a RETURN statement.

The RETURN statement should only be used to terminate a subroutine or function.

At the end of the compilation process an accounting of all unresolved references to labels is given. Labels being referenced outside the module must be declared. This is accomplished by using the label name (in column #1) followed by the word “EXTERNAL”. This will satisfy the compiler but if the label is not really used in another module to be linked, a linker error will occur. What actually occurs is that the label is put into the symbol table but no code is generated. Once a label is declared as EXTERNAL it cannot also be a local label and if it is a linker error will occur.

Also, if there is a GOSUB to a particular subroutine, that subroutine must exist.

IMPORTANT!

The last statement of a subroutine must be a RETURN. Any RETURN statement before the end of a subroutine must be inside a control structure such as a FOR loop or WHILE/ENDWHILE block. Violations of these rules will result in a “nesting” error.

The RETURN statement transfers control back to the caller and is also used to return integer or floating point data to the caller in the case of integer or floating point functions. For example:

RETURN x+y

There are also special “computed” GOTO and GOSUB statements as well as run-time error vectoring. Refer to the sections on ON GOTO, ON GOSUB and ON ERROR GOTO for a detailed description of these statements.

ON...GOTO, ON...GOSUB, ON ERROR

The ON...GOTO and ON...GOSUB statements are used to branch or branch to subroutine based on the value of and integer expression. The general syntax is as follows:

ON X GOTO Label1, Label2, Label3, etc.
ON X GOSUB Label1, Label2, Label3, etc.

The value X is any integer-valued expression. The list of Labels is ordered list of vectors which are invoked based upon the value of X and the Label’s position in the list. For example, if X evaluates too 2, then the program will GOTO or (GOSUB) to Label2 in the list. If X evaluates to less then 1 or more than the position of the last Label in the list, the next statement in line will be executed. These statements are sometimes referred to as Computed GOTO or Computed GOSUB. An example of the Computed GOTO follows:

DIM Command:INTEGER
Start PRINT “Enter Command”;
INPUT Command
ON Command GOTO Command1,Command2,Command3
PRINT “Command must be a digit from 1 to 3”
GOTO Start
Command1 PRINT “Command 1 was entered”
GOTO Start
Command2 PRINT “Command 2 was entered”
GOTO Start
Command3 PRINT “Command 3 was entered”
GOTO Start

An equivalent program not using the Computed GOTO follows:

DIM Command:INTEGER
Start PRINT “Enter Command”
INPUT Command
IF Command=1 THEN Command1
IF Command=2 THEN Command2
IF Command=3 THEN Command3
PRINT “Command must be a digit from 1 to 3”
GOTO Start
Command1 PRINT “Command 1 was entered”
GOTO Start
Command2 PRINT “Command 2 was entered”
GOTO Start
Command3 PRINT “Command 3 was entered”
GOTO Start

The ON ERROR statement is used to trap any run-time error and vector control to the Label specified in the statement. An ON ERROR statement without a GOTO turns off the trap.

ON ERROR GOTO TrapVect \ turns on the trap, vectors to TrapVec
ON ERROR \ turns off the trap, vectors to system

FOR, TO, STEP, NEXT

The FOR loop control structure begins with the FOR statement followed by the loop variable (an integer) followed by the TO verb followed by the limit expression (an integer) followed by an optional STEP verb with its step expression (an integer) followed by the loop body followed by the NEXT statement which includes the loop variable. The loop variable following the NEXT is optional.

The body of a FOR loop will not execute at all if the loop variable has exceeded the limit variable. The comparison is a >= test (<= if step is negative).

As with all control structures, the FOR loop structure may also be exited with the EXITIF statement.

It is good programming practice to indent statements within the structure for better readability. Some examples follow:

FOR I=1 TO 10
PRINT I
NEXT I\ the ‘I’ is optional

The above example is equivalent to:

I=0
Loop1
I=I+1
PRINT I
IF I<11 THEN Loop1

IF, THEN, ELSE, ENDIF

The IF, ELSE, and ENDIF statements are used to test conditions and direct program flow based on the result of the test. The statements are normally used together in a control structure (ELSE is optional) except in one special case in which, the THEN is followed by a LABEL. In this case (which is provided for compatibility with older Basics) there is no assumed structure to follow such as ELSE or ENDIF. ENDIF may also be expressed as END IF. Except in the case where THEN is followed by a LABEL (or line number), the THEN clause may be ommited.

The following is an example of the special case mentioned above:

Loop
A=A+1
IF A<100 THEN Loop

In this example there is no control structure. Each time the IF statement is encountered, the variable A is tested and if it is less than 100 the program loops back to the label Loop.

In the control structure case the structure begins with the IF statement, is optionally followed by the ELSE statement, and ends with the ENDIF statement. It is good programming practice to indent statements within the structure for better readability. For example:

IF A>B THEN
   PRINT “A is more than B”
ELSE
   PRINT “A is less than or equal to B”
ENDIF

IF statements may also be used in conjunction with the boolean operators AND and OR. In addition, IF statements may be nested. Also the control structure may be exited before the ENDIF statement is reached by using the EXITIF statement. For example:

IF A>B
   EXIT IF X=Y
   IF X>Y AND X=A THEN
      PRINT “Hello”
   ELSE
      PRINT “Bye”
   END IF
END IF

The compiler keeps track of the control structures and reports an error if there are any unbalanced control structures in the program.

SELECT CASE, CASE, END SELECT

The SELECT CASE, CASE, and END SELECT statements form a control structure, which is useful for testing a number of cases of a test variable. ENDSELECT may also be expressed as END SELECT.

A numerical example:

SELECT CASE X
    CASE 1
       PRINT “1”
    END CASE
    CASE 2 TO 6
       PRINT “2 TO 6”
    END CASE
    CASE ELSE
       PRINT “No match”
    END CASE
END SELECT

A string example:

INPUT A$
SELECT CASE A$
    CASE “pop”
       PRINT “pop”
    CASE “soda”
       PRINT “soda”
    CASE ELSE
       PRINT “water”
END SELECT

ENDCASE may also be expressed as END CASE. (ENDCASE IS OPTIONAL)

WHILE, DO, ENDWHILE

The WHILE/DO/ENDWHILE control structure begins with the WHILE statement followed by the test condition followed by the DO verb followed by the body followed by the ENDWHILE statement. The DO verb is optional. ENDWHILE may also be expressed as END WHILE or WEND.

In this control structure, the condition is tested before any code in the body is executed. At each pass through the structure, the condition as tested and as long as the condition is true, the code body is executed.

As with all control structures, the WHILE/DO/ENDWHILE structure may also be exited with the EXITIF statement.

It is good programming practice to indent statements within the structure for better readability. For example:

WHILE NOT(EOF(#InpFile)) DO
   READ #InpFile,Text
   PRINT Text
ENDWHILE

The WHILE statement may also contain the boolean operators AND and OR. For Example:

WHILE A<B AND A<>0
   A=A+2
END WHILE

An equivalent to the above example would be:

Loop1
IF A<B AND A<>0 THEN
   A=A+2
   GOTO Loop1
ENDIF

REPEAT, UNTIL

The REPEAT/UNTIL control structure begins with the REPEAT statement followed by the body followed by the UNTIL statement where a condition is tested. If the condition is true, the program proceeds to the next statement after the UNTIL statement. If the condition is false, control goes to the statement following the REPEAT statement.

As with all control structures, the REPEAT/UNTIL structure may also be exited with the EXITIF statement.

It is good programming practice to indent statements within the structure for better readability. For example:

REPEAT
   INPUT X
UNTIL X=4
PRINT “done”

In the above example the user will be prompted to enter data to the INPUT statement until a value of 4 is entered. When a 4 is entered “done” will be printed on the CRT.

Since the condition is tested at the “bottom” of the control structure, the statement(s) in the body of the structure will always be executed at least once.

The UNTIL statement may also contain the boolean operators AND and OR.
For Example:

REPEAT
   a=x*5/3
   EXITIF a=0
   y=a/2
UNTIL a=y OR y=100

An equivalent to the above example would be:

Loop1
a=c*5/3
IF a=0 THEN Loop2
y=a/2
IF a<>y AND y<>100 THEN Loop1
Loop2

LOOP, LOOP COUNT, ENDLOOP, EXITIF, ENDEXIT, CONTINUE

The LOOP/ENDLOOP control structure is an unconditional loop, which will never end unless an EXITIF statement is used in the body of the loop (or a GOTO statement leaves the loop). While the GOTO statement will cause the loop to be exited, it is considered bad (or at least unstructured) programming practice. ENDLOOP may also be expressed as END LOOP.

The general use of the LOOP/ENDLOOP control structure is as follows:

A=100
LOOP
   A=A-1
   EXITIF A=0
   B=B+3
ENDLOOP

In the example above, the variable A is decremented until it reaches a value of 0 at which time the control structure is exited.

Using the LOOP COUNT statement an equivalent structure can be made as follows:

LOOP COUNT=100
   B=B+3
END LOOP

There are some restrictions on the use of the LOOP COUNT statement:

As many LOOP/COUNT’s may be active as desired, but care must be taken to exit “gracefully” by letting the count expire or by using the EXITIF statement because the LOOP/COUNT (unlike the other control structures) uses a stack for nesting purposes. Therefore, jumping into the middle of a LOOP/COUNT structure will also cause a stack imbalance.

The EXITIF statement may also be used with an optional THEN followed by a body of code followed by an ENDEXIT statement. This form allows the coding of an “end event” before exiting the structure. ENDEXIT may also be expressed as END EXIT. For example:

WHILE NOT(EOF(#FileNum)) DO
   READ #FileNum,A$
   EXITIF A$=“quit” THEN
   PRINT “done”
   ENDEXIT
END WHILE

The CONTINUE statement may be used in any of the OmniBasic control structures to start the next iteration without completing the current one. CONTINUE must be followed by IF. For example:

FOR I=1 TO 100
   INPUT X
   CONTINUE IF X<0
   X=X*2
NEXT I

This may be used with:

FOR/NEXT
LOOP/ENDLOOP
REPEAT/UNTIL
WHILE/ENDWHILE

The effect is to do the next iteration inside the control structure.

DATA, RESTORE, READ

The DATA statement is used to build tables of constants. The constants may be integer (long), string, boolean, or floating point. The first DATA statement in a list or table must be a labeled statement so that the RESTORE statement can set the DATA read pointer at the beginning of the list. The data in the list is read using READ statements until the data is exhausted at which time the read pointer is reset to the value of the last RESTORE statement. The general syntax for the DATA statement is as follows:

Label DATA Element,Element,...Element

The Label is required on the first line of a data list and is referenced by the RESTORE statement. The term “Element” refers to an integer, floating point, boolean, or string constant. Integer constants may be expressed as compiler variables which will assume the value of the last #SET directive for that compiler variable. Commas separate the Elements.

The RESTORE statement in OmniBasic requires the label argument, which is used to point to the beginning if the DATA table to be read. The general syntax of the RESTORE statement is as follows:

RESTORE Label

This statement causes the read data pointer to point to the data at Label. It should be noted here that the RESTORE statement will point to any Label it is instructed to whether there are DATA statements there or not.

The READ statement accesses the data sequentially through the data table and assigns the data to the variables specified in the READ statement. It is important to maintain a correspondence between the order of the data in the DATA statements and the variables in the READ statement. The general syntax of the READ statement is as follows:

READ Var,Var,...Var

The READ keyword is followed by a space followed by a list of variables separated by commas. The data type of the variables should correspond to the implied data type of the data in the DATA list being read. For instance reading a quoted string into an integer variable would have unpredictable and possibly disastrous effect.

The following is an example using the DATA, RESTORE, and READ statements:

DIM A(4):INTEGER
DIM B(4):INTEGER
DIM C(4):INTEGER
DIM A$(4):STRING[20}
DIM Count:INTEGER
Start
   RESTORE DataTable
   FOR Count=1 to 4
      READ A(Count),B(Count),C(Count),A$(Count)
   NEXT Count
END
DataTable DATA 2,2,2,”first”
DATA 4,2,7,”second”
DATA 3,7,5,”third”
DATA 4,4,8,”fourth”

In the above example we read the data into arrays of corresponding data type. The FOR loop terminates before the data in the data-table runs out. In the following example the reading of the data in the data table will terminate by detecting a flag in the data itself.

DIM KeyWord:STRING[10]
DIM Command:STRING[10]
DIM KeyNumber:INTEGER
Start
   PRINT “Enter Command”;
   INPUT Command
   GOSUB KeyFind
   REM Count now contains the “code number” of the key word or 4 if not found
END
KeyFind RESTORE KeyTable
KeyNumber=0
ReadLoop
KeyNumber=KeyNumber+1
READ KeyWord
IF KeyWord=”%” THEN
   RETURN
ENDIF
IF KeyWord=Command THEN
   RETURN
ENDIF
GOTO ReadLoop
KeyTable DATA “run”
DATA “stop”
DATA “pause”
DATA “%”

LET, ERR, STATUS, NextArg, POS, XferCount, ProgramName

The LET statement is used to assign a value to a variable. There is also a form of the LET statement, which is referred to as the IMPLIED LET statement. The IMPLIED LET statement is simply a LET statement in which the LET keyword is omitted. Most programs and programmers opt for the IMPLIED LET form. The general syntax is as follows:

LET Var=Expr

The IMPLIED LET form is:

Var=Expr

The expression (Expr) must be of the same data class as the variable (Var) or a type mismatch error will occur. If the variable is a BYTE type and the expression is a SHORT OR LONG type, the expression result is demoted to the BYTE type. The same type of demotion occurs if the variable is a SHORT type and the expression is a LONG type. If the variable is a LONG type and the expression is a BYTE or SHORT type, the expression is promoted etc. When a result is demoted, the result is truncated to the destination data size.

The special variable ERR is set when an error occurs to the code of that error. If the program has set up an ON ERROR GOTO trap, the trap can test this variable to see what type of error has occurred. ERR is synonymous with error (the standard C error variable).

The special variable STATUS contains the status of the last input/output operation. Using the STATUS prefix to an input/output operation may circumvent error trapping. The special variable XferCount is set to the value of STATUS after a successful I/O operation.

STATUS:OPEN #fn,”testfile”:read
IF STATUS=-1 THEN...\ -1 indicates that the file could not be opened
STATUS:READ #fn,A$
IF STATUS=-1 THEN....\ -1 is an error status

The special variable NextArg is a variable of type STRING. It may be “read” but cannot be set. The use of NextArg involves setting a STRING variable to NextArg. Each time a STRING is assigned NextArg, the next argument of the command line is extracted. Each time an argument is extracted, the user should check the length to determine if this argument is the last. The arguments use “space” as a delimiter. The following example prints the arguments of the command line. Keep in mind that the arguments may be scanned only once in a program.

DIM A$:STRING[80]
Start
   A$=NextArg
   IF LEN(A$)<>0 THEN
      PRINT A$
   ELSE
      END
   ENDIF
GOTO Start

The special variable POS is set by the PRINT statement to the last print position reached. It is of data type LONG. The special variable XferCount is used to determine the number of bytes transferred on the last I/O operation. It is of data type LONG.

The special use of the ProgramName is set when the program is loaded for execution by the system.

DIM A$ AS STRING * 28
A$=ProgramName
PRINT A$:

BUFFER, BUFADR(), BUFSIZ(), SETBUFADR

The BUFFER statement in conjunction with the BUFADR and BUFSIZ functions allows the use of dynamically allocated memory buffers with OmniBasic. The primary use of this capability is when it is not known what size (volume) the data will be at compile time. An example of this condition might be when using OmniBasic to write an editor program. When a command is encountered to read a file into the edit buffer the size of that file is unknown at compile time. Therefore the program could be written to check the file size and allocate an appropriately sized memory buffer. The explanation in the use of memory buffers necessarily involves the use of pointer variables or vectors (not a part of ordinary BASIC(s)) so a study of data types may be in order. The general syntax of the BUFFER statement is as follows:

BUFFER BufName=BufSize

BufName is any valid OmniBasic symbol name and must be unique from any other symbol name used in the program including variables, labels, etc. If the BufName has not been used already in the program, it will be added to the symbol table. The equal sign is required and is followed by an integer expression. The system will (at run time) attempt to allocate BufSize bytes to the program. If the spare memory is not available, a system error will be returned. Also the BUFSIZ function may be used to verify the amount of memory actually granted. The amount of the memory may be rounded up to an integral of the system minimum allocation value. If and when the program is done with the memory buffer, the buffer may be returned to system memory. The syntax for accomplishing this is the same as the BUFFER statement already shown with two exceptions. The BufSize is set to zero (0) and must be a constant (not a variable). An example of this is as follows:

BUFFER BufName=0

Or

#SET BufSize=0
BUFFER BufName=BufSize

An example of setting up a memory buffer and assigning a pointer variable to it follows:

DIM BufferSiz:INTEGER
#SET Null=0
DIM Temp:INTEGER
DIM BufferPtr:BYTE POINTER \ establish BufferPtr as a BYTE POINTER variable
BufferSiz=4000 \ assign a value of 4000 to BufferSiz
BUFFER MyBuffer=BufferSiz\ create a buffer called MyBuffer having 4000 bytes
IF BUFSIZ (MyBuffer)<BufferSiz then 200\ rem go take care of error condition
REM The next three lines set the entire buffer to Null bytes FOR Temp=1 to BUFSIZ(MyBuffer)
[BufferPtr]=Null
BufferPtr=INDEX(BufferPtr,1)
NEXT Temp
...
200 PRINT “memory requested is not available”

It is important to avoid re-assigning buffers before releasing them or going out of bounds.

The SETBUFADR statement allows just one buffer structure to control any number of buffers by maintaining a table of open buffers and then closing any buffer by:

BUFFER BufName=2000
x=BUFADR (BufName)

…

SETBUFADR BufName=x
BUFFER BufName=0

(NOTICE: This is for advanced programmers; be advised that an invalid SETBUFADR can cause a system crash or data loss.)

INC, DEC, INDEX(), SETVEC

The INC and DEC statements are used to add or subtract one to or from the integer variable specified. Also the INC and DEC statements may be used to add or subtract the size of the data type pointed to by a pointer variable. This allows pointer variables to sequentially scan arrays.

The INDEX() function is used to index pointer variables and is useful to randomly access arrays in memory.

The General form of the INC and DEC statements is as follows:

INC IntVar
DEC IntVar

or

INC PtrVar
DEC PtrVar

Examples of the INC and DEC statements follow:

DIM A:BYTE
DIM B:WORD
DIM C:LONG
TYPE USR=STRING[10];X:LONG
DIM D:USR POINTER
Start
   A=100
   B=200
   C=300
   D=1000
   INC A\ A now equals 101
   INC B\ B now equals 201
   DEC C\ C now equals 299
   INC D\ D now points to 1014 (10+4+1000)

Note that the INC and DEC statements do not work with data type float.

The general form of the INDEX() function is as follows:

INDEX(PtrVar,IntExpr)

For example:

DIM Ptr:LONG POINTER
Start
   Ptr=$FF0000
   Ptr=INDEX(Ptr,2)\ Ptr now points to $FF0008 (4*2+$FF0000)

The SETVEC statement is used to assign an address to a VECTOR.
For Example:

SETVEC VarName=Addr
SETVEC StringVar=Addr,StringSize\ StringSize is optional (default is DIM size)

Next Page: Chapter 10 Part 2
Table of Contents