BASIC [/qualifier...][ file-spec [/qualifier...]],...

Indicates a specific action to be performed by the compiler on all files or specific files listed. When a qualifier appears directly after the BASIC command, it affects all files listed.

Indicates the name of the input source file that contains the program or module to be compiled. You are not required to specify a file extension; the VSI BASIC compiler assumes the default file type .BAS.

$ BASIC/LIST/OBJ PROG1/NOOBJ/DIAG,PROG2+PROG3/NOLIST

VSI BASIC does not require line numbers in either of the source files. The "+" operator is treated as an OpenVMS append operator. VSI BASIC appends and compiles the separate files as if they were a single source file.

The following list shows the BASIC command qualifiers and their defaults. A description of each qualifier follows the list.

The qualifiers that are "declining features" and no longer recommended are separately described in Section 2.1.3, “Declining Qualifiers and Their Recommended Replacements”.

See the description of the /[NO]FLAG = [NO]DECLINING qualifier in this chapter. Also see the descriptions of the /INTEGER_SIZE and /REAL_SIZE qualifiers in this chapter. The old qualifiers are described in the VSI BASIC Reference Manual.

$ BASIC/LISTING prog-name

If the program is compiled as a batch job, the listing file is created by default; specify the /NOLISTING qualifier to suppress creation of the listing file. By default, the name of the listing file is the name of the source program followed by the file type .LIS. You can include a file specification with the /LISTING qualifier to override this default.

LINK[ /command-qualifier]... {file-spec [/file-qualifier...]},...

Specifies one or more output file options.

Specifies the input file or files to be linked.

Specifies one or more input file options.

If you specify more than one input file, you must separate the input file specifications with plus signs (+) or commas (,). By default, the linker creates an output file with the name of the first input file specified and the file type .EXE. When you link more than one file, list the file containing the main program first. This way, the name of your output file will have the same name as that of your main program module.

$ LINK DANCE.OBJ, CHACHA.OBJ, SWING.OBJ

The LINK command qualifiers can be used to modify linker output, as well as to invoke the debugging and traceback facilities. Linker output consists of an image file and an optional map file. Image file qualifiers, map file qualifiers, and debugging and traceback qualifiers are described in this section.

This section summarizes some of the most commonly used LINK command qualifiers. For a complete list and description of LINK qualifiers, see the VSI OpenVMS Linker Utility Manual.

When you enter the LINK command interactively and do not specify any qualifiers, the linker creates only an executable image file. By default, the resulting image file has the same file name as the first object module specified, and the file type .EXE.

In a batch job, the linker creates both an executable image file and a storage map file by default. The default file type for map files is .MAP.

$ LINK UPDATE/MAP=TEST

$ LINK GARDEN, VEGGIES/INCLUDE = (EGGPLANT,TOMATO,BROCCOLI,ONION)

This example directs the linker to link the object modules EGGPLANT, TOMATO, BROCCOLI, and ONION with the main object module GARDEN.

Besides program modules, an object module library can also contain a symbol table with the names of each global symbol in the library, and the name of the module in which they are defined. You specify the name of the object module library containing symbol definitions with the /LIBRARY qualifier. When you use the /LIBRARY qualifier during a link operation, the linker searches the specified library for all unresolved references found in the included modules during compilation.

$ LINK BADMINTON, TENNIS, RACQUETBALL, RACQUETS/LIBRARY

You can define an object module library, such as LNK$LIBRARY, to be your default library by using the DCL command DEFINE. The linker searches default user libraries for unresolved references after it searches modules and libraries specified in the LINK command. See the VSI OpenVMS DCL Dictionary for more information about the DEFINE command.

For more information about object module libraries, see the VSI OpenVMS Linker Utility Manual.

If the linker detects any errors while linking object modules, it displays messages indicating the cause and severity of the error. If any error or fatal error conditions occur (errors with severities of E or F), the linker does not produce an image file.

If an error occurs when you link modules, you can often correct the error by reentering the command string and specifying the correct modules or libraries.

See the OpenVMS System Messages and Recovery Procedures Reference Manual for a complete list of linker messages.

Even with fast hardware and an optimizing compiler, you can still tune your code for run-time performance. This section provides recommendations to consider if further performance improvements are desirable.

To achieve the best performance for your application, it is important to let both the hardware and the optimizer/code generator take advantage of their full capabilities. This can be accomplished by minimizing, and in some cases avoiding, the use of language features and qualifiers that block optimal program execution.

Noscreen mode is the default, line-oriented mode of displaying input and output. To get into noscreen mode from screen mode, enter SET MODE NOSCREEN. See the sample debugging session in Section 3.7, “Sample Debugging Session” for a demonstration of noscreen mode.

DBG> TYPE 3
3:    EXTERNAL SUB TRIPLE    &
DBG>

DBG> TYPE TEST\16:21

--SRC: module SAMPLE$MAIN -scroll-source--------------------------
     1:  10     !SAMPLE
     2:
     3:         EXTERNAL SUB TRIPLE        &
     4:                     ,PRINT_SUB
     5:
     6:         WHEN ERROR USE HANDLER_1
  -> 7:           CALL TRIPLE
     8:           CALL PRINT_SUB
     9:
- OUT -output---------------------------------------------
stepped to SAMPLE$MAIN\%LINE 7




- PROMPT -error-program-prompt----------------------------
DBG> STEP
DBG>

The PROMPT display, at the bottom of the screen, shows the debugger prompt (DBG>), your input, debugger diagnostic messages, and program output. In the example, the debugger commands that have been issued are shown.

The OUT display, in the center of the screen, captures the debugger's output in response to the commands that you issue.

The SRC and OUT displays are scrollable so that you can see whatever information scrolls beyond the display window's edge. Press KP8 to scroll up and KP2 to scroll down. Press KP3 to change the display to be scrolled (by default, the SRC display is scrolled). Scrolling a display does not affect program execution.

%DEBUG-I-SOURCESCOPE, Source lines not available for .0\%PC.
        Displaying source in a caller of the current routine.

There are two commands for starting or resuming program execution: GO and STEP. The GO command starts execution. The STEP command lets you execute a specified number of source lines or instructions.

GO Command

The GO command starts program execution, which continues until forced to stop. You will probably use the GO command most often in conjunction with breakpoints, tracepoints, and watchpoints. If you set a breakpoint in the path of execution and then enter the GO command (or press the keypad comma key that executes the GO command), execution will be suspended when the program reaches that breakpoint. If you set a tracepoint, the path of execution through that tracepoint will be monitored. If you set a watchpoint, execution will be suspended when the value of the watched variable changes.

You can also use the GO command to test for an exception condition or an infinite loop. If an exception condition that is not handled by your program occurs, the debugger will take over and display the DBG> prompt so that you can issue commands. If you are using screen mode, the pointer in the source display will indicate where execution stopped. You can then use the SHOW CALLS command (see Section 3.4.2, “Determining the Current Location of the Program Counter”) to identify the currently active routine calls (the call stack).

In the case of an infinite loop, the program will not terminate, so the debugger prompt will not reappear. To obtain the prompt, interrupt the program by pressing Ctrl/Y and then issue the DCL command DEBUG. You can then look at the source display and a SHOW CALLS display to locate the PC.

STEP Command

The STEP command (which you can use either by entering STEP or by pressing KP0) allows you to execute a specified number of source lines or instructions, or to execute the program to the next instruction of a particular kind, for example, to the next CALL instruction.

DBG> STEP
stepped to TEST\COUNTER\%LINE 27
     27:   X = X + 1
DBG>

The PC is now at the first machine code instruction for line 27 of the module TEST; line 27 is in COUNTER, a routine within the module TEST. TEST\COUNTER\%LINE 27 is a directory specification. The debugger uses directory specifications to refer to symbols. (However, you do not need to use a path name in referring to a symbol, unless the symbol is not unique; in that case, the debugger will issue an error message). See the VSI OpenVMS Debugger Manual or online help for more information about resolving multiply-defined symbols.

DBG> STEP 3

Note that only those source lines for which code instructions were generated by the compiler are recognized as executable lines by the debugger. The debugger skips over any other lines—for example, comment lines.

Also, if a line has more than one statement on it, the debugger will execute all the statements on that line as part of the single step.

Using the STEP/OVER command to step over a GOSUB statement will still proceed to the target of the GOSUB since this statement is just a special kind of GOTO statement and not a routine call.

You can specify different stepping modes, such as stepping by instruction rather than by line (SET STEP INSTRUCTION). To resume to the default behavior, enter the SET STEP LINE command. Also by default, the debugger steps over called routines—execution is not suspended within a called routine, although the routine is executed. By entering the SET STEP INTO command, you tell the debugger to suspend execution within called routines as well as within the currently executing module. To resume the default behavior, enter the SET STEP OVER command.

DBG> SHOW CALLS
 module name      routine name       line     rel PC    abs PC

*TEST             PRODUCT              18    00000009  0000063C
*TEST             COUNTER              47    00000009  00000647
*MY_PROG          MY_PROG              21    0000000D  00000653
DBG>

This example indicates that execution is currently at line 18 of routine PRODUCT (in module TEST), which was called from line 47 of routine COUNTER (in module TEST), which was called from line 21 of routine MY_PROG (in module MY_PROG).

The SET BREAK command lets you select breakpoints, which are locations at which the program will stop running. When you reach a breakpoint, you can enter commands to check the call stack, examine the current values of variables, and so on.

DBG> SET BREAK COUNTER
DBG> GO
    .
    .
    .
 break at TEST\COUNTER
      34:  SUB COUNTER(LONG X,Y)
DBG>

In this example, the SET BREAK command sets a breakpoint on the subprogram COUNTER; the GO command starts execution. When the subprogram COUNTER is encountered, execution is suspended, the debugger announces that the breakpoint at COUNTER has been reached (break at ...), displays the source line (34) where execution is suspended, and prompts you for another command. At this breakpoint, you can step through the subprogram COUNTER, using the STEP command, and use the EXAMINE command (see Section 3.5.1, “Displaying the Values of Variables”) to check on the current values of X and Y.

When using the SET BREAK command, you can specify program locations using various kinds of address expressions (for example, line numbers, routine names, instructions, virtual memory addresses). With high-level languages, you typically use routine names, labels, or line numbers, possibly with directory specifications to ensure uniqueness.

DBG> SET BREAK %LINE 41

DBG> SET BREAK SCREEN_IO\%LINE 58

DBG> SET BREAK/LINE
DBG> SET BREAK/CALL

DBG> SET BREAK LOOP3 DO (EXAMINE TEMP)
DBG> GO
    .
    .
    .
break at COUNTER\LOOP3
      37:    LOOP3: FOR I = 1 TO 10
COUNTER\TEMP:   284.19
DBG>

DBG> SHOW BREAK
breakpoint at SCREEN_IO\%LINE 58
breakpoint at COUNTER\LOOP3
    do (EXAMINE TEMP)
    .
    .
    .
DBG>

To cancel a breakpoint, enter the CANCEL BREAK command, specifying the program location exactly as you did when setting the breakpoint. The CANCEL BREAK/ALL command cancels all breakpoints.

The SET TRACE command lets you select tracepoints, which are locations for tracing the execution of your program without stopping its execution. After setting a tracepoint, you can start execution with the GO command and then monitor the PC's path, checking for unexpected behavior. By setting a tracepoint on a routine, you can also monitor the number of times the routine is called.

DBG> SET TRACE COUNTER
DBG> GO
    .
    .
    .
trace at TEST\COUNTER
      34:  SUB COUNTER(LONG X,Y)
    .
    .
    .

When using the SET TRACE command, you specify address expressions, qualifiers, and optional clauses exactly as with the SET BREAK command.

DBG> SET TRACE/LINE/NOSYSTEM/NOSHARE

DBG> SET TRACE\SILENT %LINE 83 DO (EXAMINE STATUS)
DBG> GO
    .
    .
    .
SCREEN_IO\CLEAR\STATUS:   'OFF'
    .
    .
    .

The SET WATCH command lets you set watchpoints that will be monitored continuously as your program executes.

DBG> SET WATCH TOTAL

Subsequently, every time the program modifies the value of TOTAL, the watchpoint is triggered. The debugger monitors watchpoints continuously during program execution.

DBG> SET WATCH TOTAL
DBG> GO
    .
    .
    .
watch of SCREEN_IO\TOTAL\%LINE 13
      13:   TOTAL = TOTAL + 1
     old value: 16
     new value: 17
break at SCREEN_IO.%LINE 14
      14:   CALL Pop_rtn(TOTAL)
DBG>

In this example, a watchpoint is set on the variable TOTAL and the GO command starts execution. When the value of TOTAL changes, execution is suspended. The debugger announces the event (watch of …), identifying where TOTAL changed (line 13) and the associated source line. The debugger then displays the old and new values and announces that execution has been suspended at the start of the next line (14). (The debugger reports break at … , but this is not a breakpoint; it is still the effect of the watchpoint.) Finally, the debugger prompts for another command.

When a change in a variable occurs at a point other than the start of a source line, the debugger gives the line number plus the byte offset from the start of the line.

DBG> EXAMINE variable_name

The debugger recognizes the compiler-generated data type of the specified variable and retrieves and formats the data accordingly. The following examples show some uses of the EXAMINE command:

DBG> EXAMINE EMPLOYEE_NAME
PAYROLL\EMPLOYEE_NAME:    "Peter C. Lombardi"
DBG>

DBG> EXAMINE WIDTH, LENGTH, AREA
SIZE\WIDTH:   4
SIZE\LENGTH:  7
SIZE\AREA:   28 
DBG>

DBG> EXAMINE INTEGER_ARRAY
PROG2\INTEGER_ARRAY
   (0,0):       27
   (0,1):       31
   (0,2):       12
   (1,0):       15
   (1,1):       22
   (1,2):       18
DBG>

DBG> EXAMINE CHAR_ARRAY(4)
PROG2\CHAR_ARRAY(4): 'm'
DBG>

Note that the EXAMINE command can be used with any kind of address expression (not just a variable name) to display the contents of a program location. The debugger associates certain default data types with untyped locations. You can override the defaults for typed and untyped locations if you want the data to be interpreted and displayed in some other data format. The debugger supports the data types and operators of BASIC including RECORDs and RFAs.

See Section 3.5.3, “Evaluating Expressions” for an explanation of how the EXAMINE and the EVALUATE commands differ.

DBG> DEPOSIT variable_name = value

The DEPOSIT command is like an assignment statement in BASIC.

In the following examples, the DEPOSIT command assigns new values to different variables. The debugger checks that the value assigned, which may be a language expression, is consistent with the data type and dimensional constraints of the variable.

DBG> DEPOSIT PARTNUMBER = "WG-7619.3-84"

DBG> DEPOSIT WIDTH = CURRENT_WIDTH + 10

DBG> DEPOSIT C_ARRAY(12) = 'K'

You can specify any kind of address expression, not just a variable name, with the DEPOSIT command (as with the EXAMINE command). You can override the defaults for typed and untyped locations if you want the data to be interpreted in some other data format.

DBG> EVALUATE lang_exp

DBG> DEPOSIT WIDTH = 45
DBG> EVALUATE WIDTH + 7
52
DBG>

DBG> DEPOSIT WIDTH = 45
DBG> EVALUATE WIDTH
45
DBG> EXAMINE WIDTH
SIZE\WIDTH:   45

DBG> EVALUATE WIDTH + 7
52
DBG> EXAMINE WIDTH + 7
SIZE\WIDTH:   131584

With the EVALUATE command, WIDTH + 7 is interpreted as a language expression, which evaluates to 45 + 7, or 52. With the EXAMINE command, WIDTH + 7 is interpreted as an address expression: 7 bytes are added to the address of WIDTH, and whatever value is in the resulting address is reported (in this example, 131584).

When using the OpenVMS Debugger, all VSI BASIC for OpenVMS variable and label names within a single program unit must be unique; otherwise, the debugger will be unable to determine the symbol to which you are referring.

In a multiple-unit program with line numbers, any comments following an END, END SUB, or END FUNCTION statement become a part of the previous subprogram during compilation unless they begin on a numbered line. This is not the case in multiple-unit programs without line numbers.

Although line numbers are not required, you might want to use them on every line that can cause a run-time error, depending on the type of error handling you use. See Chapter 15, Handling Run-Time Errors for more information about handling run-time errors.

In a multiple-unit program without line numbers, any comments following an END, END SUB, or END FUNCTION statement become a part of the next subprogram during compilation (unless there is no next subprogram). This is not the case in multiple-unit programs with line numbers.

You can avoid all of these restrictions by placing a line number on the first line of your program; no additional line numbers are required. The line number on the first program line causes the compiler to compile your program as a program with line numbers.

When you write a program with or without line numbers, you can begin your program statements in the first character position on a line.

!This is a short program that does not contain any
!BASIC line numbers.
!This program must be entered using a text editor;
!it cannot be entered directly into the environment.
!
PRINT "This program converts kilogram weight to pounds"
INPUT "How many kilograms";A
!This is the conversion factor
B = A / 2.2
PRINT "For ";A;" kilograms, the pound weight is ";B
END

Output

This program converts kilogram weight to pounds
How many kilograms? 11
For  11  kilograms, the pound weight is  5

You can use exclamation comment fields instead of REM statements to insert comments into programs without line numbers. An exclamation point in column 1 causes the VSI BASIC compiler to ignore the rest of the line. You can also identify program statements in programs without line numbers by using labels.

A label is a 1- to 31-character identifier that you use to identify a block of statements. All label names must begin with a letter; the remaining characters, if any, can be any combination of letters, digits, dollar signs ($), underscores (_), or periods (.), but the final character cannot be a dollar sign.

When you use a label to mark a program location, you must end the label with a colon (:). The colon is used to show that the label name is being defined instead of referenced. When you reference the label, do not include the colon.

OPTION TYPE = EXPLICIT        ! Require declarations
DECLARE INTEGER A
   .
   .
   .
Outer_loop:
      IF A <> B
      THEN
Inner_loop:
      IF B = C
        THEN
          A = A + 1
          GOTO Outer_loop
        ELSE
          B = B + 1
          GOTO Inner_loop
        END IF
      END IF

Labels have no effect on the order in which program lines are executed; they are used to identify a statement or block of statements.

If a program line is too long for one line of text, you can continue the program line by placing an ampersand ( &) at the end of the line. Note that only spaces and tabs are valid between the ampersand and the carriage return.

OPEN "SAMPLE.DAT" AS FILE #2%,       &
      SEQUENTIAL VARIABLE,           &
      RECORDSIZE 80%

IF (A$ = B$)
THEN
   PRINT "The two values are equal"
ELSE
   PRINT "The two values are different"
END IF

PRINT A \ PRINT V \ PRINT G

Because all statements are on the same program line, any reference to this program line refers to all three statements.

The default data type is SINGLE on Alpha BASIC and SFLOAT on I64 BASIC. However, you can specify your own default at DCL command level or with the OPTION statement in your program. For more information about establishing default data types, see Chapter 2, Developing VSI BASIC Programs, as well as the OPTION statement in the VSI BASIC Reference Manual.

The first time the variable is referenced, it creates a variable with that name and data type and allocates storage for that variable.

A% = 10.1
B% = 20.5
PRINT A% + B%

30

With explicit data typing, you use a declarative statement to name and specify a data type for your program values.

All declarative statements associate a data type with a variable. For more information, see Chapter 7, Data Definition.

A floating-point variable is a named location that stores a floating-point value. The storage space required to hold the value depends on the variable's REAL subtype. For example, each SINGLE floating-point variable requires 32 bits (4 bytes) of storage, while each DOUBLE floating-point variable requires 64 bits (8 bytes) of storage.

Note that if any integer value is assigned to a floating-point variable, the value is converted to a floating-point number.

An integer variable is a named location that stores a whole number. The storage space required to hold the value depends on the variable's INTEGER subtype. For example, each BYTE integer variable requires 8 bits (1 byte) of storage, while each LONG integer variable requires 32 bits (4 bytes) of storage.

B% = -5.7

DECLARE WORD CONSTANT Word_const = -32767 - 1

A packed decimal (DECIMAL data type) variable is made up of several storage locations, the number of which depends on the declared size of the variable. However, a packed decimal variable is still referred to by a single variable name.

When you declare a packed decimal variable, you specify the total number of digits and the number of digits to the right of the decimal place that you want.

OPTION TYPE = EXPLICIT
DECLARE DECIMAL (8,2) My_decimal

Packed decimal numbers are most useful for dollars-and-cents calculations.

A subscripted variable is a floating-point, integer, packed decimal, RFA, or string variable that is part of an array. Chapter 6, Arrays describes arrays in more detail.

An array is a set of data organized in one or more dimensions. A one-dimensional array is called a list or vector. A two-dimensional array is called a matrix. Arrays can have up to 32 dimensions.

When you create an array, its size is determined by the number of dimensions and the maximum size, called the bound, of each dimension. Subscripts begin by default with 0, not 1. That is, when calculating the number of elements in a dimension, you count from zero to the bound specified.

DECLARE INTEGER My_array (10, 10)

OPTION TYPE = EXPLICIT,        &
       SIZE = REAL SINGLE

DECLARE REAL Birth_rates(1945 TO 1985)

The INPUT, INPUT LINE, and LINPUT statements prompt a user for data while the program runs.

INPUT "PLEASE TYPE 3 INTEGERS" ;B% ,C% ,D%
A% = B% + C% + D%
PRINT "THEIR SUM IS"; A%
END

PLEASE TYPE 3 INTEGERS? 25,50,75 Return
THEIR SUM IS 150

INPUT A,B
END

? 5 Return
? 6 Return

? 5 Return 
?   Return

INPUT A,B,C
PRINT A,B,C
END

? 5,6,7,8 Return
 5            6            7

INPUT "Please type a number"; A$
PRINT A$

Please type a number? 25.5
25.5

INPUT LINE A$
LINPUT B$
LINPUT C$
PRINT A$, B$, C$
PRINT "DONE"
END

? SINGLE, DOUBLE Return
? "GFLOAT" Return
? HFLOAT; REAL Data Types Return

SINGLE, DOUBLE
"GFLOAT"     HFLOAT; REAL Data Types
DONE

INPUT "Please input 3 integer values";A%, B%, C%

Please input 3 integer values?

SET NO PROMPT
INPUT "Please input 3 integer values";A%, B%, C%

Please input 3 integer values

SET NO PROMPT
INPUT "Please enter your name: ";Employee_name$

Please enter your name:

SET PROMPT
INPUT "Please enter your name: ";Employee_name$

Please enter your name: ?

The following sections describe the READ, DATA, and RESTORE statements. To use READ and DATA statements, you must know what data is required when writing the program. These statements do not stop to request data while the program runs; therefore, your program runs faster than with the INPUT statements.

The RESTORE statement lets you use the same data items more than once.

10    WHEN ERROR USE catch_it
         DATA 1%, 2%, 3%
20       READ A%, B%, C%
      END WHEN
400   HANDLER catch_it
         PRINT "ERROR NUMBER IS "; ERR
         PRINT "ERROR AT LINE "; ERL
         PRINT "ERROR MESSAGE IS "; ERT$(ERR)
      END HANDLER
500   END

ERROR NUMBER IS 50
ERROR AT LINE 20
ERROR MESSAGE IS %Data format error

10 DATA "ABRAMS", BAKER, CHRISTENSON, &
        DOBSON, "EISENSTADT", FOLEY

READ A$
DATA ABC !COMMENT

DATA "The circumference is"
DATA 40.5
READ text$
READ radius
CIRCUMFERENCE = PI * radius * 2
PRINT text$; CIRCUMFERENCE
END

 The circumference is 254.469

10 READ B,C,D
20 RESTORE
30 READ E,F,G
40 DATA 6,3,4,7,9,2
50 END

A terminal line contains zones that are 14 character positions wide. The number of zones in a line depends on the width of your terminal: a 72-character line contains 5 zones, which start in columns 1, 15, 29, 43, and 57. A 132-character line has additional print zones starting at columns 71, 85, 99, and 113.

INPUT A ,B ,C ,D ,E ,F
PRINT A ,B ,C ,D ,E ,F
END

Output

? 5,10,15,20,25,30 Return
 5             10            15            20           25
 30

A = 5
B = 10
PRINT "first zone",,"third zone"
PRINT A,,B
END

Output

first zone                   third zone
 5                            10

PRINT 10; 20
PRINT "ABC"; "XYZ"
END

Output

 10  20
ABCXYZ

INPUT X,Y,Z
PRINT X,Y,
PRINT Z
END

Output

? 5,10,15
 5            10                 15

!No comma after I%, so each element
!Prints on its own line
!
PRINT I% FOR I% = 1% TO 10%
PRINT
!
!A comma follows J%, so each
!element prints in a separate zone
!
MARGIN 80%
PRINT J%, FOR J% = 1% TO 10%
PRINT
!
!A semicolon follows K%, so print
!elements are packed together
!
PRINT K%; FOR K% = 1% TO 10%
END

Output

1

2

3

4

5

6

7

8

9

10

1             2             3              4               5

6             7             8              9               10

1  2  3  4  5  6  7  8  9  10

PRINT "first zone",,"third zone",,"fifth zone"
END

Output

first zone                  third zone                  fifth zone

PRINT "abcdefghijklmnopqrstuvwxyz","pizza"
PRINT "first zone","second zone","third zone"

Output

abcdefghijklmnopqrstuvwxyz  pizza
first zone    second zone   third zone

PRINT 'PRINTING "QUOTATION" MARKS'
END

Output

PRINTING "QUOTATION" MARKS

The PRINT statement displays only up to 6 digits of precision for floating-point numbers. This corresponds to the precision of the SINGLE or SFLOAT data types. To display the extra digits in DOUBLE, GFLOAT, TFLOAT, or XFLOAT numbers, you must use the PRINT USING statement. See Chapter 14, Formatting Output with the PRINT USING Statement for more information about the PRINT USING statement.

FOR I = 1 TO 20
    PRINT 2^(-I),I,2^I
NEXT I
END

Output

 .5              1               2
 .25             2               4
 .125            3               8
 .0625           4               16
 .03125          5               32
 .015625         6               64
 .78125E-02      7               128
 .390625E-02     8               256
 .195313E-02     9               512
 .976563E-03     10              1024
 .488281E-03     11              2048
 .244141E-03     12              4096
 .12207E-03      13              8192
 .610352E-04     14              16384
 .305176E-04     15              32768
 .152588E-04     16              65536
 .767939E-05     17              131072
 .38147E-05      18              262144
 .190735E-05     19              524288
 .953674E-06     20              .104858E+07

You use the OPEN statement to create a file, or to gain access to an existing file. If you do not specify either FOR INPUT or FOR OUTPUT in the OPEN statement, BASIC tries to open an existing file. If the file does not exist, BASIC creates a new one.

The channel specification lets you associate a number with the file for as long as the file is open. All I/O operations to or from the file use this number.

When you are finished accessing a file, you close it with the CLOSE statement.

PRINT "This program creates a daily sales report file named SALES.DAT"
OPEN "SALES.DAT" FOR OUTPUT AS FILE #4%
PRINT #4%, "Salesperson","Sales Area","Items Sold"
PRINT #4%
INPUT "How many salespersons for today's report"; sales_persons%
FOR I% = 1% TO sales_persons%
    INPUT "Salesperson's name"; s_name$
    INPUT "Sales area"; area$
    INPUT "Number of items sold"; items_sold%
    PRINT #4%, s_name$, area$, items_sold%
NEXT I%
CLOSE #4%
END

Output

This program creates a daily sales report file named SALES.DAT
How many salespersons for today's report? 3
Salesperson's name? JONES
Sales area? NJ
Items sold? 5
Salesperson's name? SMITH
Sales area? NH
Items sold? 6
Salesperson's name? BAINES
Sales area? VT
Items sold? 8

This program first prints a header explaining its purpose, then opens a terminal-format file on channel 4. After this file is opened, the two PRINT # statements place an explanatory header followed by a blank line into the file.

The program then prompts you for the number of salespersons for which data is to be entered. The FOR...NEXT loop prompts for the name, sales area, and items sold for each salesperson. The FOR...NEXT loop executes only as many times as there are salespersons. See Chapter 9, Program Control for more information about FOR...NEXT loops.

After the data has been entered for each salesperson, the program writes this information to the terminal-format file. Because the response to the first question was 3, the FOR...NEXT loop executes three times.

$ TYPE SALES.DAT

Salesperson   Sales Area    Items Sold

JONES         NJ             5
SMITH         NH             6
BAINES        VT             8

DECLARE LONG FIRST_ARRAY(1980 TO 1990)

Note that the STRING data type with the DECLARE statement causes the creation of an array of dynamic strings. To create an array of fixed-length strings, declare the array in a COMMON or MAP statement or as part of a RECORD structure.

Even if the DIM statement contains a data type keyword, the array name can still end in the appropriate data type suffix. This makes the data type of the array immediately obvious.

The DIM statement can be either executable or declarative. If the specified bounds are constants, the DIM statement is declarative. This means that the storage is allocated at compile time, and the array cannot appear in any other DIM statement.

When an array is redimensioned with the executable DIM statement, the array can become larger or smaller than it was. However, redimensioning an array in this way causes it to be reinitialized, and all data in the array is lost.

In contrast, MAT statements let you redimension an array to be the same size or smaller than it was. However, MAT statements redimension arrays only when assigning values or performing matrix I/O; therefore, the fact that MAT statements reinitialize the array does not matter. See Section 6.6, “Using MAT Statements” for more information about MAT statements.

DIM #1%, STRING VIRT_ARRAY(100) = 256%

X% = 10%
Y% = 20%
DIM real_array(X%)
real_array(1%) = 100
PRINT real_array(1%)
DIM real_array(Y%)
PRINT real_array(1%)
END

100
0

Create arrays with the COMMON statement when you need an array of fixed-length strings, or when you want to share an array among program modules. Program modules can share arrays in COMMON statements by defining a common block with the same name.

!Main Program
COMMON (ABC) STRING access_list(1 TO 100) = 10

!Subprogram
SUB SUB1
COMMON (ABC) STRING new_list(1 TO 100) = 10

Create arrays with the MAP statement only when you want the array to be part of a record buffer, or when you want to overlay the storage containing the array. Note that string arrays in maps are always fixed-length.

You associate the array with a record buffer by naming the map in the MAP clause of the OPEN statement.

MAP (ABC) STRING team(10) = 20, WORD bowling_scores(0 TO 32)
OPEN "BOWLING.DAT" AS FILE #1%, SEQUENTIAL VARIABLE, MAP ABC

The array name can specify an existing array. MAT statements do not assign values to row and column zero.

DIM A(10,10), B(15), C(20,20)
MAT A = ZER             !Sets all elements of A to 0
MAT B = CON(10)         !Sets elements of B to 1; redimensions B
MAT C = IDN(10,10)      !Redimensions C to 10x10 identity matrix
PRINT "ARRAY A:"
MAT PRINT A;
PRINT
PRINT "ARRAY B:"
MAT PRINT B;
PRINT
PRINT "ARRAY C:"
MAT PRINT C;

Output

ARRAY A:
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0

ARRAY B:
1  1  1  1  1  1  1  1  1  1

ARRAY C:
1  0  0  0  0  0  0  0  0  0
0  1  0  0  0  0  0  0  0  0
0  0  1  0  0  0  0  0  0  0
0  0  0  1  0  0  0  0  0  0
0  0  0  0  1  0  0  0  0  0
0  0  0  0  0  1  0  0  0  0
0  0  0  0  0  0  1  0  0  0
0  0  0  0  0  0  0  1  0  0
0  0  0  0  0  0  0  0  1  0
0  0  0  0  0  0  0  0  0  1

The MAT READ statement assigns values from DATA statements to array elements. Subscripts define either the dimensions of the array being created or the new dimensions of an existing array; subscripts are optional in MAT READ statements.

If you do not provide enough data in DATA statements to fill the specified array, BASIC leaves the remaining array elements unchanged. If you provide more data values than there are array elements, BASIC assigns enough values to fill the array and leaves the DATA pointer at the next value.

MAT READ B(2,2)
MAT READ C(2,2)
PRINT
PRINT "MATRIX B"
PRINT
PRINT
MAT PRINT B;
PRINT
PRINT "MATRIX C"
PRINT
PRINT
MAT PRINT C;
DATA 1,2,3,4,5,6,7,8,9,10
END

Output

MATRIX B

 1  2
 3  4
MATRIX C

 5  6
 7  8

The MAT INPUT statement assigns values from your terminal to array elements. The MAT INPUT statement reads data from a terminal-format file and writes it to an array. The optional subscripts in a MAT INPUT statement define either the dimensions of the array being created implicitly or the new dimensions of an existing array. If you are implicitly creating the array, the value of a subscript cannot exceed 10.

The MAT INPUT statement requests data from your terminal, as does the INPUT statement; it prints a question mark (?) prompt that you can disable with the SET NO PROMPT statement and then enable with the SET PROMPT statement. However, you cannot include a string prompt with the MAT INPUT statement.

When you enter a series of values separated by commas, BASIC enters the values you supply into successive array elements by row, starting with element (1,1) and filling row 1 before starting row 2. If you provide fewer data items than there are elements, the remaining elements are unchanged. If you provide more items than there are elements, BASIC ignores the excess.

The MAT INPUT statement takes values from an open file and assigns them to the matrix elements by rows, starting with element (1,1). It fills the elements in row 1 before starting row 2. The file can have one or more values in each record; however, multiple values must be separated with commas.

MAT INPUT #3, A
PRINT
MAT PRINT A;
MAT INPUT B(2,2)
PRINT
MAT PRINT B;

Output

  1  2  3  4  5  6  7  8  9  10
 11 12 13  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0
  0  0  0  0  0  0  0  0  0  0

? 1,2,3,4

 1  2
 3  4

Note that the MAT PRINT statement does not print row and column zero. For more information about the MAT PRINT statement, see Section 6.6.5, “MAT PRINT [#] Statement”.

DIM new_array%(5,5)
MAT INPUT new_array%(2,4)
MAT PRINT new_array%;
END

Output

 ? 1,2,3,4,5,6,7,8

 1 2 3 4
 5 6 7 8

When entering values in response to MAT INPUT, you can enter an ampersand (&) as the last character on the line and continue on the next line.

The MAT LINPUT statement assigns string values to string array elements. The MAT LINPUT statement reads string values from a terminal-format file and writes them to a string array.

DIM emp_nam$(5,5)
MAT LINPUT emp_nam$(2,2)
PRINT emp_nam$(1,1)
PRINT emp_nam$(1,2)
PRINT emp_nam$(2,1)
PRINT emp_nam$(2,2)
END

Output

? SMITH
? JONES
? WHITE
? BLACK
SMITH
JONES
WHITE
BLACK

By specifying the subscripts (2,2), MAT LINPUT redimensions the array to nine elements and overwrites the old values (assigning the values in the same manner as MAT INPUT; see Section 6.6.3, “MAT INPUT [#] Statement”). BASIC then prompts for these elements.

MAT LINPUT also excludes line terminators when assigning values to string array elements. MAT LINPUT places the values from the open file into the specified array, filling the array by rows, starting with element (1,1). If there are more values in the file than there are array elements, BASIC ignores the excess records. If there are fewer, BASIC assigns a null string to the remaining elements.

DIM part_name$(50)
MAT LINPUT #1%, part_name$

The MAT PRINT statement prints some or all of an array's elements, excluding row and column zero. The MAT PRINT # statement takes values from an array by row, starting with element (1,1), and writes each element to a sequential record in the terminal-format file.

Subscripts are optional in MAT PRINT statements. If you do not specify subscripts, MAT PRINT displays the entire array, excluding row and column zero. If you specify subscripts, MAT PRINT displays the specified subset of the array. In the case of the MAT PRINT # statement, the subscripts determine how many array elements are written to the file. The MAT PRINT [#] statement does not redimension an existing array.

If the last character in the MAT PRINT [#] array list is a semicolon, BASIC begins each array row on a separate line. Data values on each line are packed together with no intermediate spaces. However, if the last character in the MAT PRINT [#] array list is a comma, BASIC begins each array row on a separate line and each data value in a separate print zone.

MAT INPUT A(5)
PRINT
MAT PRINT A
PRINT
MAT PRINT A, A;
MAT PRINT #3, A, A;
END

Output

? 5

  5
  0
  0
  0
  0

  5         0           0           0           0

  5  0  0  0  0

MAT statements do not signal error messages when there are more data items than array elements to contain them or when there are fewer data items than array elements to contain them.

BASIC provides two functions that let you determine how much data the MAT statements transfer: NUM and NUM2.

For two-dimensional arrays, the NUM function returns an integer value specifying the row number of the last data item transferred, and the NUM2 function returns an integer value specifying the column number of the last data item transferred. For one-dimensional arrays, the NUM function returns the number of items entered, and the NUM2 function returns a zero.

OPEN "EMP.DAT" FOR INPUT AS FILE #3%
DIM emp_name$(5,5)
MAT INPUT #3%, emp_name$
PRINT NUM, NUM2
END

Output

 4               2

MAT operators perform matrix assignment, addition, subtraction, and multiplication.

MAT new_array = old_array

MAT sum_list% = first_list% + second_list%

DIM first_array(30,30)
DIM second_array(30,30)
DIM difference_array(30,30)
   .
   .
   .
MAT difference_array = first_array - second_array

DIM A(2,2), B(2,2), C(2,2)
A(1,1) = 1
A(1,2) = 2
A(2,1) = 3
A(2,2) = 4
B(1,1) = 5
B(1,2) = 6
B(2,1) = 7
B(2,2) = 8
MAT C = A * B
MAT PRINT C

 19
 22
 43
 50

DIM inch_array(5), cm_array(5)
MAT READ inch_array
DATA 1,12,36,100,39.37
MAT cm_array = (2.54) * inch_array
MAT PRINT cm_array,
END

 2.54     30.48     91.44     254     99.9998

With these functions, you can transpose and invert matrices and find the determinant of an inverted matrix.

DIM B(3,5)
MAT READ B
MAT A = TRN(B)
DATA 1,2,3,4,5
DATA 6,7,8,9,10
DATA 11,12,13,14,15
MAT PRINT B;
MAT PRINT A;
END

 1 2 3 4 5
 6 7 8 9 10
 11 12 13 14 15

 1  6   11
 2  7   12
 3  8   13
 4  9   14
 5  10  15

MAT INPUT first_array(3,3)
MAT PRINT first_array;
PRINT
MAT inv_array = INV (first_array)
MAT PRINT inv_array;
PRINT
MAT mult_array = first_array * inv_array
MAT PRINT mult_array;
PRINT
D = DET
PRINT D

? 4,0,0,0,0,2,0,8,0
 4  0  0
 0  0  2
 0  8  0

 .25  0  0
 0  0  .125
 0  .5  0

 1  0  0
 0  1  0
 0  0  1

 -64

COMMON (code) STRING emp.code=2, wage.code=3, dep.code=22

COMMON (into) LONG call_count, sub1_count, sub2_count
COMMON (into) LONG sub3_count, sub4_count

When you explicitly declare an array, VSI BASIC for OpenVMS allows you to specify both upper and lower bound values. The value you supply as the upper bound determines the maximum subscript value for a given dimension, and the value you supply for the lower bound determines the minimum subscript value for a given dimension.

For more information about specifying bounds with the COMMON statement, see Chapter 6, Arrays and the VSI BASIC Reference Manual.

The MAP statement, like the COMMON statement, creates a named area of static storage. However, if a program module contains multiple maps with the same name, the maps are overlaid on the same area of storage, rather than being concatenated.

When used with the MAP clause of the OPEN statement, the storage allocated by the MAP statement becomes the record buffer for that file. Variables in the MAP statement correspond to fields in the file's records.

When you explicitly declare an array, VSI BASIC for OpenVMS allows you to specify both upper and lower bound values. The value you supply as the upper bound determines the maximum subscript value for a given dimension, and the value you supply for the lower bound determines the minimum subscript value for a given dimension.

For more information about specifying bounds with the MAP statement, see Chapter 6, Arrays and the VSI BASIC Reference Manual.

WHEN ERROR USE eof_handler
DECLARE INTEGER CONSTANT EOF = 11

MAP (PAYROL) STRING emp_name, LONG wage_class,     &
                        STRING sal_rev_date, SINGLE tax_ytd

OPEN "payroll.dat" FOR INPUT AS FILE #4%           &
                      ,ORGANIZATION SEQUENTIAL     &
                      ,ACCESS READ                 &
                      ,MAP PAYROL

OPEN "payrol.new" FOR OUTPUT AS FILE #5%           &
             ,ORGANIZATION SEQUENTIAL              &
             ,ACCESS WRITE                         &
             ,MAP payrol

PRINT "PAYROLL VERIFICATION"


 get_loop:
     WHILE 1% = 1%
         GET #4
         PRINT emp_name, wage_class, sal_rev_date, tax_ytd
         PRINT "YOU CAN CHANGE:"
         PRINT "1. EMPLOYEE NAME"
         PRINT "2. WAGE CLASS"
         PRINT "3. REVIEW DATE"
         PRINT "4. TAX YEAR-TO-DATE"
         PRINT "5. DONE"

 read_loop:
        WHILE 1% = 1%
         INPUT "CHANGES? ANSWER WITH YES OR NO" ; chng$
         IF chng$ = "NO" THEN ITERATE get_loop
                  ELSE INPUT "NUMBER" ;number%

         END IF

         SELECT number%
         CASE 1
              INPUT "EMPLOYEE NAME"; emp_name
         CASE 2
              INPUT "WAGE CLASS"; wage_class
         CASE 3
              INPUT "REVIEW DATE";sal_rev_date
         CASE 4
              INPUT "TAX YEAR-TO-DATE"; tax_ytd
         CASE 5
              EXIT read_loop
         CASE ELSE
              PRINT "Invalid response -- please try again"
         END SELECT
        NEXT
        PUT #5
     NEXT
END WHEN
HANDLER eof_handler
   IF ERR = EOF
     THEN
            PRINT "End of file"
     ELSE
            EXIT HANDLER
   END IF
END HANDLER
END

7.7.2.2. Multiple Maps

When a program contains more than one map with the same name, the storage allocated by these MAP statements is overlaid. This technique is useful for manipulating strings. Figure 7.1, “Multiple Maps” shows multiple maps and maps in use.

When you use more than one map to access a record buffer, VSI BASIC for OpenVMS uses the size of the largest map to determine the size of the record. (The RECORDSIZE clause of the OPEN statement can override this map-defined record size. For more information, see Chapter 13, File Input and Output.)

You can also use multiple maps to interpret numeric data in more than one way. The following example creates a map area named barray. The first MAP statement allocates 26 bytes of storage in the form of an integer BYTE array. The second MAP statement defines this same storage as a 26-byte string named ABC. When the FOR...NEXT loop executes, it assigns values corresponding to the ASCII values for the uppercase letters A to Z.

MAP (barray) BYTE alphabet(25)
MAP (barray) STRING ABC = 26
FOR I% = 0% TO 25%
    alphabet(I%) = I% + 65%
NEXT I%
PRINT ABC
END

Output

ABCDEFGHIJKLMNOPQRSTUVWXYZ

FILL items reserve space in map and common blocks and in record buffers accessed by MOVE or REMAP statements. Thus, FILL items mask parts of the record buffer and let you skip over fields and reserve space in or between data elements.

MAP (QED) STRING A, FILL$=24, LONG SSN, FILL%, REAL SAL, FILL(5)

RECORD X
   REAL Y1, Y2(10)
END RECORD X
MAP (QED) X FILL

See Chapter 8, Creating and Using Data Structures for more information about the RECORD statement.

The COMMON and MAP statements create a block of storage called a PSECT. This common or map storage block is accessible to any subprogram. A VSI BASIC for OpenVMS main program and subprogram can share such an area by referencing the same common or map name.

!In a main program
COMMON (A1) STRING A, B = 10, LONG C
   .
   .
   .
!In a subprogram
COMMON (A1) STRING X, Z = 10, LONG Y

If a subprogram defines a common or map area with the same name as a common or map area in the main program, it overlays the common or map defined in the main program.

COMMON (XYZ) STRING A = 32
COMMON (XYZ) STRING B = 32

!In the main program
COMMON (XYZ) STRING A = 32
   .
   .
   .
!In the subprogram
COMMON (XYZ) STRING B = 32

COMMON (SHARE) WORD emp_num,               &
            DECIMAL (8,0) salary,          &
            STRING wage_class = 2
   .
   .
   .
!In the main program
%INCLUDE "COMMON.BAS"
   .
   .
   .
!In the subprogram
%INCLUDE "COMMON.BAS"

If you use the %INCLUDE directive, you can lessen the risk of a typographical error. For more information about using the %INCLUDE directive, see Chapter 16, Compiler Directives.

MAP (REDEF) STRING full_name = 40
   .
   .
   .
!In the main program
%INCLUDE "MAP.BAS"
   .
   .
   .
!In the subprogram
%INCLUDE "MAP.BAS"
MAP (REDEF) STRING first_name=15, MI=1, last_name=24

The MAP DYNAMIC statement does not affect the amount of storage allocated. The MAP DYNAMIC statement causes VSI BASIC for OpenVMS to create internal pointers to the variables and array elements. Until your program executes the REMAP statement, the storage for each variable and each array element named in the MAP DYNAMIC statement starts at the beginning of the map storage area.

The MAP DYNAMIC statement is nonexecutable. With this statement, you cannot specify a string length. All string items have a length of zero until the program executes a REMAP statement.

The REMAP statement specifies the new positions of variables named in the MAP DYNAMIC statement. That is, it causes VSI BASIC for OpenVMS to change the internal pointers to the data. Because the REMAP statement is executable, it can redefine the pointer for a variable or array element each time the REMAP statement is executed.

With the MAP DYNAMIC statement, you can specify either a map name or a previously declared static string variable. When you specify a map name, a MAP statement with the same map name must lexically precede the MAP DYNAMIC statement.

DECLARE LONG CONSTANT emp_fixed_info = 4 + 9 + 2
MAP (emp_buffer) LONG badge,                     &
                 STRING social_sec_num = 9,      &
                 BYTE name_length,               &
                      address_length,            &
                      FILL (60)

MAP DYNAMIC (emp_buffer) STRING emp_name,        &
                                emp_address

WHILE 1%
GET #1
REMAP (emp_buffer) STRING FILL = emp_fixed_info,              &
                                 emp_name = name_length,      &
                                 emp_address = address_length

NEXT

At the start of program execution, the storage for badge is the first 4 bytes of emp_buffer, the storage for social_sec_num is equal to 9 bytes, and together name_length and address_length are equal to 2 bytes. The FILL keyword reserves 60 additional bytes of storage. The MAP DYNAMIC statement defines the variables emp_name and emp_address whose positions and lengths will change at run time. When executed, the REMAP statement defines the FILL area to be equal to emp_fixed_info and defines the positions and lengths of emp_name and emp_address.

When you specify a static string variable, it must be either a variable declared in a MAP or COMMON statement or a parameter declared in a SUB, FUNCTION, PICTURE, or DEF. The actual parameter passed to the procedure must be a static string variable defined in a COMMON, MAP, or RECORD statement.

SUB deblock (STRING input_rec, STRING item())
 MAP DYNAMIC (input_rec) STRING A(1 TO 3)
 REMAP (input_rec) &
     A(1) = 5, &
     A(2) = 3, &
     A(3) = 4
 FOR I = LBOUND(A) TO UBOUND(A)
   item(I) = A(I)
 NEXT I
END SUB

Note that dynamic map variables are local to the program module in which they reside; therefore, REMAP only affects how that module views the buffer.

For more information about using the MAP DYNAMIC and REMAP statements, see the VSI BASIC Reference Manual.

A RECORD component can consist of a named group of instances, identified with the keyword GROUP. You use GROUP to refer to a collection of RECORD components, or to create an array of components that have different data types. The GROUP name can be followed by a list of upper and lower bounds, which define an array of the GROUP components. GROUP is valid only within a RECORD block.

The declarations between the GROUP statement and the END GROUP statement are called a GROUP block.

RECORD Yacht

  GROUP Type_of_yacht
    STRING Manufacturer = 10
    STRING Model = 10
  END GROUP Type_of_yacht
  GROUP Specifications
    STRING Rig = 6
    STRING Length_over_all = 3
    DECIMAL(5,0) Displacement
    DECIMAL(2,0) Beam
    DECIMAL(7,2) Price
  END GROUP Specifications

END RECORD Yacht

Sometimes it is useful to have different record components overlay the same record field, in much the same way that multiple maps can overlay the same storage. Such an overlay is called a RECORD variant. You use the keywords VARIANT and CASE to set up RECORD variants.

RECORD Boat

  STRING Make  = 10
  STRING Model = 10
  STRING Type_of_boat = 1    ! This field contains the value S, P, or C.
                             ! Value S causes the record instance to be
                             ! interpreted as describing a sailboat, value
                             ! P as describing a powerboat, and value C as
                             ! describing a canoe.
  VARIANT

  CASE     ! Sailboats

    STRING Rig   = 20
  CASE     ! Powerboats

    WORD   Horsepower

  CASE     ! Canoes

    WORD   Length
    WORD   Weight

  END VARIANT

END RECORD

! Declarations

DECLARE Boat My_boat

! Main program logic starts here

   .
   .
   .
Input_boat_information:

  INPUT 'Make of boat'; My_boat::Make
  INPUT 'Model';        My_boat::Model
  PRINT 'Type of boat (S = Sailboat, P = Powerboat, C = Canoe)';
  INPUT My_boat::Type_of_boat
  SELECT My_boat::Type_of_boat

  CASE "S"

    INPUT 'Sail rig'; My_boat::Rig

  CASE "P"

    INPUT 'Horsepower'; My_boat::Horsepower
  CASE "C"

     INPUT 'Length'; My_boat::Length
     INPUT 'Weight'; My_boat::Weight

  CASE ELSE

     PRINT "Invalid type of boat, please try again."

  END SELECT

The value of the Type_of_boat component determines the format of the variant part of the record.

!Record templates

RECORD Emp_wage_class

  STRING Emp_name = 30         ! Employee name string.

  STRING Street = 15           !
  STRING City = 20             ! These components make up the
  STRING State = 2             ! employee address field.
  DECIMAL(5,0) Zip             !

  STRING Wage_class = 1
  VARIANT

    CASE

      GROUP Hourly                     ! Hourly workers.

        DECIMAL(4,2) Hourly_wage       ! Hourly wage rate.
        SINGLE Regular_pay_ytd         ! Regular pay year-to-date.
        SINGLE Overtime_pay_ytd        ! Overtime pay year-to-date.

      END GROUP Hourly
    CASE

      GROUP Salaried                   ! Salaried workers.

        DECIMAL(7,2) Yearly_salary     ! Yearly salary.
        SINGLE Pay_ytd                 ! Pay year-to-date.

      END GROUP Salaried
    CASE

      GROUP Executive                  ! Executives.

        DECIMAL(8,2) Yearly_salary     ! Yearly salary.
        SINGLE Pay_ytd                 ! Pay year-to-date.
        SINGLE Expenses_ytd            ! Expenses year-to-date.

      END GROUP Executive

  END VARIANT

END RECORD
! Declarations:

  DECLARE Emp_wage_class Emp

! Main Program logic starts here.


LINPUT "Name"; Emp::Emp_name          ! Use LINPUT statements for
LINPUT "Street"; Emp::Street          ! string fields so the entire
                                      ! string is assigned to the
LINPUT "State"; Emp::State            ! variable.
INPUT  "Zip Code"; Emp::Zip
LINPUT "Wage Class"; Emp::Wage_class
SELECT Emp::Wage_class

CASE "A"
  INPUT 'Rate';Emp::Hourly_wage
  INPUT 'Regular pay';Emp::Regular_pay_ytd
  INPUT 'Overtime pay';Emp::Overtime_pay_ytd

CASE "B"
  INPUT 'Salary';Emp::Salaried::yearly_salary
  INPUT 'Pay YTD';Emp::Salaried::pay_ytd

CASE "C"
  INPUT 'Salary';Emp::Executive::yearly_salary
  INPUT 'Pay YTD';Emp::Executive::pay_ytd
  INPUT 'Expenses';Emp::Expenses_ytd

END SELECT

Variant fields can appear anywhere within the RECORD instance. When you use RECORD variants, you imply that any RECORD instance can contain any one of the listed variants. Therefore, if each variant requires a different amount of space, BASIC uses the case that requires the most storage to determine the space allocated for each RECORD instance.

To access a particular elementary component within a RECORD that contains other groups, you use the name of the declared RECORD instance, the group name (or group names, if groups are nested), and the elementary component name, each separated by double colons (::).

DECLARE Yacht My_yacht

   .
   .
   .

PRINT My_yacht::Specifications::Rig

! RECORD templates:

RECORD Family

  GROUP Extended_family

    STRING Grandfather(1) = 30    ! Two-element fixed-length string
    STRING Grandmother(1) = 30    ! arrays for the names of maternal
                                  ! and paternal grandparents.
    GROUP Nuclear_family

      STRING Father = 30          ! Fixed-length strings for the names
      STRING Mother = 30          ! of parents.
        GROUP Children (10)       ! An 11-element array for the names and
                                  ! gender of children.
          STRING Kid = 10
          STRING Gender = 1

        END GROUP Children

    END GROUP Nuclear_family

  END GROUP Extended_family

END RECORD
! Declarations

DECLARE Family My_family
! Program logic starts here.

My_family::Extended_family::Nuclear_family::Children(1)::Kid = "Johnny"

PRINT My_family::Children(1)::Kid

END

Output

Johnny

! RECORD Templates.

RECORD Test

  INTEGER Test_integers(2)     ! 3-element array of integers.

  GROUP Group_1                ! Single GROUP containing:

    REAL   My_number           ! a real number and
    STRING Group_1_string      ! a 16-character (default) string

  END GROUP
  GROUP Group_2(5)             ! A 6-element GROUP, each element containing:

    INTEGER My_number          ! an integer and
    DECIMAL Group_2_decimal    ! a DECIMAL number.

  END GROUP

END RECORD
! Declarations

DECLARE Test Array_of_test(10)  ! Create an 11-element array of type Test...
DECLARE Test Single_test        ! ...and a separate single instance of type
                                ! Test.

Array_of_test(i)::Group_1_string 

In this case, i is the subscript for array Array_of_test. Because the RECORD instance is itself an array, the reference must include a specific array element.

Single_test::Group_1_string

Array_of_test(i)::Group_1::My_number

Single_test::Group_1::My_number

Because there is a variable named My_number in groups Group_1 and Group_2, you must specify either Group_1::My_number or Group_2(i)::My_number. In this case, extra component names are required to resolve an otherwise ambiguous reference.

Array_of_test(i)::Group_2(j)::Group_2_decimal

Single_test::Group_2(j)::Group_2_decimal

You can assign all the values from one RECORD instance to another RECORD instance, as long as the RECORD instances are identical except for names.

!RECORD Templates

RECORD Test1

  GROUP Group_1(4)

    STRING   My_string_1 = 10
    REAL     My_real_1
    INTEGER  My_integer_1

  END GROUP

END RECORD

RECORD Test2

  GROUP Group_2

    STRING  My_string_2 = 10
    REAL    My_real_2
    INTEGER My_integer_2

  END GROUP

END RECORD
RECORD Test3

  STRING   My_string_3 = 10
  REAL     My_real_3
  INTEGER  My_integer_3

END RECORD
!Declarations

DECLARE Test1 First_test1,         &
              Second_test1,        &
              Array_of_test1(3)

DECLARE Test2 First_test2

DECLARE Test3 First_test3,         &
              Array_of_test3(10)
!Program logic starts here

! A single RECORD instance is assigned to another single instance

First_test1 = Second_test1

! An array element is assigned to a single instance

Second_test1 = Array_of_test1(2)

! And vice versa

Array_of_test1(2) = Second_test1

Further, you can assign values from single RECORD instances to groups contained in other instances.

! A single instance is assigned to one group

Array_of_test1(3)::Group_1(2) = First_test1

! An array element is assigned a value from
! a group contained in another array instance
Array_of_test3(5) = Array_of_test1(3)::Group_1(3)

The examples shown in this chapter explain the mechanics of using data structures. See Chapter 12, Program Segmentation for more information about using data structures as parameters. See Chapter 13, File Input and Output for more information about using data structures for file input and output.

If you append more than one modifier to a statement, you are nesting modifiers. VSI BASIC for OpenVMS evaluates nested modifiers from right to left. If the test of the rightmost modifier fails, control passes to the next statement, not to the preceding modifier on the same line.

A = 5
B = 10
C = 15

PRINT "A =";A IF A = 5 UNLESS C = 15
PRINT "B =";B UNLESS C = 15 IF B = 10
PRINT "C =";C IF B = 10 UNLESS C = 5
END

Output

C = 15

In a FOR...NEXT loop, you specify a loop control variable (the loop index) that determines the number of loop iterations. This number must be a scalar (unsubscripted) variable. When VSI BASIC for OpenVMS begins execution of a FOR...NEXT loop, the starting and ending values of the loop control variable are known.

The FOR statement assigns the control variable a starting value and an ending value. You can use the optional STEP clause to specify the amount to be added to the loop control variable after each loop iteration.

Note that VSI BASIC for OpenVMS performs the test before the loop executes. When the control variable exceeds the ending value, VSI BASIC for OpenVMS exits the loop, and then subtracts the step value from the control variable. This means that after loop execution, the value of the control variable is the value last used in the loop, not the value that caused loop termination.

FOR I% = 1% TO 10%
    New_array(I%) = I%
NEXT I%

FOR I% = 1% TO 10% STEP 2
    New_array(I%) = I% + 1%
NEXT I%

FOR I% = 1% TO Days_in_month
    Sales_data(I%) = Quantity_sold
NEXT I%

counter% = 0%

INPUT "Start"; start%
INPUT "Finish"; finish%
INPUT "Step value"; step_val%

FOR I% = start% TO finish% STEP step_val%
    counter% = counter% + 1%
NEXT I%

PRINT "This loop executed"; counter%; "times."

Output

Start? 0
Finish? 5
Step value? -1
This loop executed 0 times.

Whenever possible, you should use integer variables to control the execution of FOR...NEXT loops because some decimal fractions cannot be represented exactly in a binary computer, and the calculation of floating-point control variables is subject to this inherent imprecision.

Loop_count_1 = 0%
Loop_count_2 = 0%

FOR Integer_variable = 1% to 100% STEP 1%
    Loop_count_1 = Loop_count_1 + 1%
NEXT Integer_variable

FOR Floating_point_variable = 0.1 to 10 STEP 0.1
    Loop_count_2 = Loop_count_2 + 1%
NEXT Floating_point_variable

PRINT "Integer loop count:"; Loop_count_1
PRINT "Integer loop end  :"; Integer_variable
PRINT "Real loop count:   "; Loop_count_2
PRINT "Real loop end:     "; Floating_point_variable

Output

Integer loop count:  100
Integer loop end:    100
Real loop count:     99
Real loop end:       9.9

Although it is not recommended programming practice, you can assign a value to a FOR...NEXT loop's control variable while in the loop. This affects the number of times a loop executes. For example, assigning a value that exceeds the ending value of a loop will cause the loop's execution to end as soon as VSI BASIC for OpenVMS performs the termination test in the FOR statement. Assigning values to ending or step variables, however, has no effect at all on the loop's execution.

A WHILE...NEXT statement uses a conditional expression to control loop execution; the loop is executed as long as a given condition is true. A WHILE...NEXT loop is useful when you do not know how many loop iterations are required.

INPUT 'Type "DONE" when finished'; Answer

WHILE (Answer <> "DONE")
   .
   .
   .
      INPUT "More data"; Answer
NEXT

Note that the NEXT statement in the WHILE...NEXT and UNTIL...NEXT loops does not increment a control variable; your program must change a variable in the conditional expression or the loop will execute indefinitely.

The evaluation of the conditional expression determines whether the loop executes. The test is performed (that is, the conditional expression is evaluated) before the first iteration; if the value is false (0), the loop does not execute.

It can be useful to intentionally create an infinite loop by coding a WHILE...NEXT loop whose conditional expression is always true. When doing this you must take care to provide a way out of the loop. You can do this with an EXIT statement or by trapping a run-time error. See Chapter 15, Handling Run-Time Errors for more information about trapping run-time errors.

The UNTIL...NEXT loop performs like a WHILE...NEXT loop, except that the logical sense of the conditional expression is reversed; that is, the UNTIL...NEXT loop executes until a given condition is true.

An UNTIL...NEXT loop executes repeatedly for as long as the conditional expression is false. Note that in UNTIL...NEXT loops, the NEXT statement does not increment a control variable. You must explicitly change a variable in the conditional expression or the loop will execute indefinitely.

INPUT 'Type "DONE" when finished.'; Answer

UNTIL (Answer = "DONE")
   .
   .
   .
      INPUT "More data"; Answer
NEXT

When a loop block is entirely contained in another loop block, it is called a nested loop.

DECLARE
   INTEGER
      Column_number,
      Row_number
   REAL
      Sales_info,
      Two_dim_array (15%, 15%)

FOR Row_number = 0% TO 15%
    FOR Column_number = 0% to 15%
        INPUT "Please enter the sales information";Sales_info
        Two_dim_array (Row_number, Column_number) = Sales_info
    NEXT Column_number
NEXT Row_number

Note that in nested loops the inner loop is entirely contained in the outer loop; nested loops cannot overlap.

Menu:
  PRINT "Would you like to change:"
  PRINT "1.  First name"
  PRINT "2.  Last name"

INPUT CHOICE%

ON CHOICE% GOTO First_name, Last_name OTHERWISE Other_choice

First_name:
   INPUT "First name"; firstname$
   GOTO Done

Last_name:
   INPUT "Last name"; lastname$
   GOTO Done

Other_choice:
    PRINT "Invalid choice"
    PRINT "Let's try again"
    GOTO Menu

Done:
    END

Note that if you do not supply an OTHERWISE clause and the control variable is less than 1 or greater than the number of targets, BASIC signals “ON statement out of range (ERR = 58)”.

The IF...THEN...ELSE statement evaluates a conditional expression and uses the result to determine which block of statements to execute next. If the conditional expression is true, VSI BASIC for OpenVMS executes the statements in the THEN clause. If the conditional expression is false, VSI BASIC for OpenVMS executes the statements in the ELSE clause, if one is present. If the conditional expression is false and there is no ELSE clause, VSI BASIC for OpenVMS executes the statement immediately following the END IF statement.

INPUT "Input number"; number

IF (number < 0)
THEN
   number = - number
   PRINT "That square root is imaginary"
   PRINT "The square root of its absolute value is";
   PRINT SQR(number)
ELSE
   PRINT "The square root is"; SQR(number)
END IF
END

Output

Input number? -9
That square root is imaginary
The square root of its absolute value is 3

Do not neglect to end an IF...THEN...ELSE statement. After an IF block is executed, control is transferred to the statement immediately following the END IF. If there is no END IF, VSI BASIC for OpenVMS transfers control to the next line number. Code between the keyword ELSE and the next line number becomes part of the ELSE clause. If there are no line numbers, the VSI BASIC for OpenVMS compiler ignores the remaining program code from the keyword ELSE to the end of the program. Therefore, it is important to end IF statements.

IF expression
THEN
    IF expression
    THEN
        statement-list
    ELSE
        IF expression
        THEN
            statement-list
        ELSE
            statement-list
ELSE

10  DECLARE INTEGER light_bulb
    DECLARE INTEGER circuit_switch
    DECLARE INTEGER CONSTANT Opened  = 0
    DECLARE INTEGER CONSTANT Closed =  1

    PRINT "Please enter zero or one, corresponding to the circuit"
    PRINT "switch being open or closed"
    INPUT On_off_val
    IF On_off_val = Opened
      THEN
        PRINT "The light bulb is off."
      ELSE
        PRINT "The light bulb is on."
    END IF
    IF On_off_val = Closed
      THEN
        PRINT "The light bulb is on."
      ELSE
        PRINT "The light bulb is off."
    PRINT "That's all for now."
20  END

Output 1

Please enter zero or one, corresponding to the circuit
switch being open or closed
? 0
The light bulb is off.
The light bulb is off.
That's all for now.

Output 2

Please enter zero or one, corresponding to the circuit
Switch being open or closed
? 1
The light bulb is on.
The light bulb is on.

IF A = B
THEN
   PRINT A IF A = 3
ELSE
   PRINT B IF B > 0
END IF

The SELECT...CASE statement lets you specify an expression (the SELECT expression), any number of possible values (cases) for the SELECT expression, and a list of statements (a CASE block) for each case. The SELECT expression can be a numeric or string value. CASE values can be single or multiple values, one or more ranges of values, or relationships. When a match is found between the SELECT expression and a CASE value, the statements in the following CASE block are executed. Control is then transferred to the statement following the END SELECT statement.

DECLARE REAL Stock_change


INPUT "Please enter stock price change";Stock_change

SELECT Stock_change

CASE <= 0.5
     PRINT "Don't sell yet."

CASE <= 1.0
     PRINT "Sell today."

CASE ELSE
     PRINT "Sell NOW!"

END SELECT
END

Output

Please enter stock price change? 2.1
Sell NOW!

If no match is found for any of the specified cases and there is no CASE ELSE block, VSI BASIC for OpenVMS transfers control to the statement following END SELECT without executing any of the statements in the SELECT block.

! This program is a skeleton command processor.
! It recognizes three VAX BASIC Environment commands:
!
!      SAVE
!      SCRATCH
!      OLD

DECLARE INTEGER CONSTANT True  = -1
DECLARE INTEGER CONSTANT False =  0

DECLARE STRING CONSTANT Null_input = ""   !This is the null string.

DECLARE STRING Command

! Main program logic starts here.

Command_loop:

WHILE True          ! This loop executes until the user types only a
                    ! carriage return in response to the prompt.

    PRINT
    PRINT "Please enter a command (uppercase only)."
    PRINT "Type a carriage return when finished."
    INPUT Command
    PRINT

    SELECT Command

    CASE Null_input                       ! If user types RETURN,
                                          ! exit from the loop
      GOTO Done                           ! and end the program.

    ! The next three cases use the SEG$ and LEN string functions.
    ! LEN returns the length of the typed string, and SEG$ searches
    ! the string literals ("SAVE", "SCRATCH", and "OLD") for a
    ! match up to that length.  Note that if the user types an "S",
    ! it is interpreted as a SAVE command only because SAVE is the
    ! first case tested.

    CASE SEG$ ( "SAVE", 1%, LEN (Command) )
      PRINT "That was a SAVE command."

    CASE SEG$ ( "SCRATCH", 1%, LEN (Command) )
      PRINT "That was a SCRATCH command."

    CASE SEG$( "OLD", 1%, LEN (Command) )
      PRINT "That was an OLD command."

    CASE ELSE
      PRINT "Invalid command, please try again."

    END SELECT
  NEXT

Done:
     END

The GOSUB statement unconditionally transfers control to a line in a subroutine. The last statement in a subroutine is a RETURN statement, which returns control to the first statement after the calling GOSUB. A subroutine can contain more than one RETURN statement so you can return control conditionally, depending on a specified condition.

A = 5
GOSUB Times_two
PRINT A

A = 15
GOSUB Times_two
PRINT A

A = 25
GOSUB Times_two
PRINT A

GOTO Done

Times_two:
    !This is the subroutine entry point
    A = A * 2
    RETURN

Done:
    END

Output

10
30
50

Note that VSI BASIC for OpenVMS signals “RETURN without GOSUB” if it encounters a RETURN statement without first having encountered a GOSUB or ON GOSUB statement.

The ON...GOSUB...OTHERWISE statement transfers control to one of several target subroutines depending on the value of a numeric expression. A RETURN statement returns control to the first statement after the calling ON GOSUB. A subroutine can contain more than one RETURN statement so that you can return control conditionally, depending on a specified condition.

INPUT "Please enter first integer value"; First_value%
INPUT "Please enter second integer value"; Second_value%

Choice:
    PRINT "Do you want to perform:"
    PRINT "1.  Multiplication"
    PRINT "2.  Division"
    PRINT "3.  Exponentiation"

INPUT Selection%

ON Selection% GOSUB Mult, Div, Expon OTHERWISE Wrong
GOTO Done

Mult:
    Result% = First_value% * Second_value%
    PRINT Result%
    RETURN

Div:
    Result% = First_value / Second_value%
    PRINT Result%
    RETURN

Expon:
    Result% = First_value% ** Second_value%
    PRINT Result%
    RETURN

Wrong:
    PRINT "Invalid selection"
    RETURN

Done:
    END

INPUT "Type a string of characters"; C$
SLEEP 120%
PRINT C$
END

The SLEEP statement is useful if you have a program that depends on another program for data. Instead of constantly checking for a condition, the SLEEP statement lets you check the condition at specified intervals.

WAIT 30%
INPUT "You have 30 seconds to type your password"; PSW$
END

The WAIT statement affects all subsequent INPUT, INPUT LINE, LINPUT, MAT INPUT, and MAT LINPUT statements. To disable a previously specified WAIT statement, use WAIT 0%.

WAIT 30%
INPUT "You have 30 seconds to type your  password"; PSW$
WAIT 0%
INPUT "What directory do you want to go to"; DIR$

The STOP statement is a debugging tool that lets you check the flow of program logic. STOP suspends program execution but does not close files.

When VSI BASIC for OpenVMS executes a STOP statement, it signals “STOP at line <line-num>.”

The END statement marks the end of a main program. When VSI BASIC for OpenVMS executes an END statement, it closes all files and halts program execution.

The END statement is optional in VSI BASIC for OpenVMS programs. However, it is good programming practice to include it. The END statement must be the last statement in the main program.

The END statement returns you to DCL command level.

Numeric functions generally return a result of the same data type as the function's parameter. For example, if you pass a DOUBLE argument to any of the trigonometric functions, they return a DOUBLE result.

If the format of a VSI BASIC for OpenVMS function specifies an argument of a particular data type, VSI BASIC for OpenVMS converts the actual argument supplied to the specified data type. For example, if you supply an integer argument to a function that expects a floating-point number, VSI BASIC for OpenVMS converts the argument to a floating-point number. Floating-point arguments that are passed to integer functions are truncated, not rounded.

The following sections discuss the VSI BASIC for OpenVMS built-in numeric functions.

READ A,B
DATA 10,-35.3
NEW_A = ABS(A)
PRINT NEW_A; ABS(B)
END

 10  35.3

PRINT INT(23.553); FIX(23.553)
PRINT INT(3.1); FIX(3.1)
PRINT INT(-45.3); FIX(-45.3)
PRINT INT(-11); FIX(-11)
END

 23  23
 3  3
-46 -45
-11 -11

!CONVERT ANGLE (X) TO RADIANS, AND
!FIND SIN, COS AND TAN
PRINT "DEGREES", "RADIANS", "SINE", "COSINE","TANGENT"
FOR I% = 0% TO 5%
    READ X
    LET Y = X * 2 * PI / 360
    PRINT
    PRINT X ,Y ,SIN(Y) ,COS(Y) ,TAN(Y)
NEXT I%

DATA 0,10,20,30,360,45
END

DEGREES       RADIANS       SINE          COSINE        TANGENT

 0             0             0             1             0

 10            .174533       .173648       .984808       .176327

 20            .349066       .34202        .939693       .36397

 30            .523599       .5            .866025       .57735

 360           6.28319       .174846E-06   1             .174846E-06

 45            .785398       .707107       .707107       1

PRINT SQR (2)

1.41421

FOR I% = 10% TO 100% STEP 10%
    PRINT LOG10(I%)
NEXT I%
END

 1
 1.30103
 1.47712
 1.60206
 1.69897
 1.77815
 1.8451
 1.90309
 1.95424
 2

READ A,B
DATA 1,2
PRINT 'e RAISED TO THE POWER'; A; " EQUALS"; EXP(A)
PRINT 'e RAISED TO THE POWER'; B; " EQUALS"; EXP(B)
END

e RAISED TO THE POWER 1 EQUALS 2.71828
e RAISED TO THE POWER 2 EQUALS 7.38906

PRINT RND,RND,RND,RND
END

 .76308      .179978      .902878      .88984

 .76308      .179978      .902878      .88984

RANDOMIZE
PRINT RND,RND,RND,RND
END

.403732       .34971       .15302       .92462

.404165       .272398      .261667      .10209

(B-A)*RND + A

FOR I% = 1% TO 10%
    PRINT (6%-4%) * RND + 4
NEXT I%
END

 5.52616
 4.35996
 5.80576
 5.77968
 4.77402
 4.95189
 5.76439
 4.37156
 5.2776
 4.53843

The following sections describe some of these functions.

test_string$ = "BAT"
PRINT ASCII(test_string$)
END

 66

PRINT "THIS PROGRAM FINDS THE CHARACTER WHOSE"
PRINT "VALUE (MODULO 256) YOU TYPE"
INPUT value%
PRINT CHR$(value%)
END

THIS PROGRAM FINDS THE CHARACTER WHOSE
VALUE (MODULO 256) YOU TYPE
 ? 69
E

THIS PROGRAM FINDS THE CHARACTER WHOSE
VALUE (MODULO 256) YOU TYPE
 ? 1093
E

Numeric strings are numbers represented by ASCII characters. A numeric string consists of an optional sign, a string of digits, and an optional decimal point. You can use E notation in a numeric string for floating-point constants.

The following sections describe some of the VSI BASIC for OpenVMS numeric string functions.

A = 5
B$ = "##.##"
Z$ = FORMAT$(A, B$)
PRINT Z$
END

 5.00

PRINT NUM$(7465097802134)
PRINT NUM$(-50)
END

 .74651E+13
-50

PRINT NUM1$(PI)
PRINT NUM1$(97.5 * 30456.23 + 30385.1)
PRINT NUM1$(1E-38)
END

3.14159
2999870
.00000000000000000000000000000000000001

A$ = NUM$(1000000)
B$ = NUM1$(1000000)
PRINT LEN(A$); "/"; A$; "/"
PRINT LEN(B$); "/"; B$; "/"
END

 8 / .1E+07 /
 7 /1000000/

A = VAL("922")
B$ = "100"
C% = VAL%(B$)
PRINT A
PRINT C%
END

 922
 100

In BASIC, string arithmetic functions process numeric strings as arithmetic operands. This lets you add (SUM$), subtract (DIF$), multiply (PROD$), and divide (QUO$) numeric strings, and express them at a specified level of precision (PLACE$).

String arithmetic offers greater precision than floating-point arithmetic or longword integers and eliminates the need for scaling. However, string arithmetic executes more slowly than the corresponding integer or floating-point operations.