QuickBasic Summary
Computer Methods in Chemical Engineering
This page will be updated later.
-------------------------------------------------------------------------------
' This is a comment
: ... separate BASIC statements on one line
_ ... placed at the end of the line to indicated that the statement
continues to the next line.
END ... end the main program (same as STOP in FORTRAN)
label: ... a name followed by a colon
BASIC uses double quotes (") to enclose a string; FORTRAN a single quote (').
-------------------------------------------------------------------------------
Declare Variable Type
Variable Types (type suffix)
variable$ ... character/string of adjustable length
variable% ... integer*2
-32,768 -- 32,767 in decimal (default)
i%=&h0 -- i%=&hFFFF in hexadecimal
i%=&o0 -- i%=&o177777 in octal
variable& ... integer*4 (double precision)
-2,147,483,648 -- 2,147,483,647
i&=&h0& -- i&=&hFFFFFFFF& in hexadecimal (The first "&" is the base; the second "&" is "double precision".)
i&=&o0& -- i&=037777777777& in octal
variable! ... real*4 (default; e.g., x! and x are treated as the same variable, but a! and a% are not.)
-3.4X10^38 -- 3.4X10^38 (~7 significant figures)
(Note "!" does not mean factorial. Ok in Excel macro, but not as formula in worksheet cells.)
variable# ... real*8 (double precision)
-1.7X10^308 -- 1.7X10^308 (~15 significant figures)
DEFINT a-z 'INTEGER ... integer (INTEGER*2)
DEFLNG a 'LONG ... double precision integer (INTEGER*4)
DEFSNG a 'SINGLE ... real (REAL*4)
DEFDBL a 'DOUBLE .,. double precision (REAL*8)
DEFSTR a 'STRING ... All variables beginning with "A" are strings,
unless specified otherwise by (%, &, !, or #)
Same as IMPLICIT in FORTRAN
declare variablename AS type ... general format
"declare" is one of the following:
DIM
COMMON
REDIM
SHARED
STATIC
"type" is one of the following:
INTEGER .. 2-byte integer
LONG .. 4-byte integer
SINGLE .. 4-byte real
DOUBLE .. 8-byte real
STRING .. character*(*)
STRING*n .. character*n
user-defined-type
ex. TYPE newtype ... define a newtype from existing types
a AS INTEGER
b AS STRING*30
END TYPE
DIM c AS newtype
DIM d (1 TO 5) AS newtype ... create array of newtype
i% = c.a ... how to access the element in a record
abc$ = c.b
i% = d(2).a ... access the element in a array record
abc$ = d(2).b
ex.
DIM i%(100) AS INTEGER
DIM i%(1 TO 100, -50 TO 50) AS INTEGER ... negative limits are allowable
DIM a!(100) AS SINGLE
DIM i% AS INTEGER ... DIM can be used to declare type for a non-array
DIM x AS newtype
DIM a AS STRING variable length string
DIM a AS STRING*10 fixed length string
DIM a$ AS STRING*10 ... no good (since a$ is a string of adjustable length)
ex.
COMMON SHARED a!, b!, n% ... same as common a, b, n in FORTRAN
but declared only once in the main program;
variable names extents to the entire module.
DIM SHARED a!, b!, n% ... same as common a, b, n in FORTRAN
ex. Share an array
common shared x(), y()
n=5.
dim x(n), y(n)
ARRAYS
Array variables do not necessarily have to be declared; compiler gives a warning.
The default lower bound in BASIC is 0.
OPTION BASE 1 ... change the default lower bound to 1 to conform with FORTRAN
The dimension can be read first before DIM statement is issued.
DIM array(10) ... DIMENSION array(10) in FORTRAN
DIM array(10,20)
DIM array (1 TO 10) AS INTEGER
DIM x(1 TO 10), y(1 TO 10, 1 TO 5)
DIM x(n%+1)
CONST a$ = "hi", b$ = "class", c$="today"
CONST pi!=3.14
.. same as FORTRAN: DATA pi/3.14/
CONST n=100 : DIM a(n) ... same as FORTRAN: parameter (n=100)
CONST n=1 ... n is treated as an integer by default, although the default is a real number in a pure expression e.g., n=1
CONST n=3! ... n is treated as a real number
CONST n!=3 ... n is treated as a real number
n = 1 ... n is treated as a real number; default varibale type is real
CALL subroutine(1) ... 1 is passed as an integer in a subroutine/function
CALL subroutine(1!) ... 1 is passed as a real number
CALL subroutine(1.) ... 1 is passed as a real number
DATA 1., 0., 0., 0. ... same as in FORTRAN
FOR I = 1 TO 4 REAL x(4)
READ x(i) DATA x/1., 0., 0., 0./
NEXT
-------------------------------------------------------------------------------
QBasic Intrinsic Functions
Math Functions ...
ABS
ATN ... ATAN in FORTRAN
COS
EXP
LOG
SGN returns -1 (negative), 0 (for 0) or 1 (positive)
SIN
SQR ... SQRT in FORTRAN
TAN
Other Functions ...
LEN(variable) ... returns the number of bytes required by a variable
LEN(string expression) ... returns the number of characters in a string
ASC("A") ... returns the ASCII code of "A";
same as FORTRAN: ICHAR('A')
CHR$(64) ... returns the character corresponding to ASCII 64;
same as FORTRAN: CHAR(64)
EOF(1) ... see if eof is reached in file/device #1 (true or false)
LOC(1) ... returns the number of bytes waiting in the input buffer
LOF(1) ... returns the number of bytes remaining in the output buffer
RSET ... right justify a string variable
LSET ... left justify a string variable
ex. LSET NewVariable$ = oldvariable$
LTRIM$ ... strip away leading spaces
ex. FOR i=1 to 5 ... produce x(1) = ???
i$ = LTRIM$(STR$(i)) x(2) = ???
PRINT "x("; i$; ") = "; :
INPUT "", x(i)
NEXT i
ex. FOR i=1 to 5 ... produce x(1) = ???
PRINT " a("; LTRIM$(STR$(i)); ")="; a(i)
NEXT i
RTRIM$ ... strip away trailing spaces
good for comparing fixed length and variable length strings
ex. IF RTRIM$(fixed$) = variable$ THEN ...
INSTR(string1$, string2$)
... returns the position in string1 where string2 is found
0 means no match
ex. string1$ = "hi, class"
string2$ = "class"
PRINT INSTR(string1$, string2) ... gives 5
INSTR(start_position%, string1$, string2$)
... returns the position in string1 where string2 is found
start searching for matching at start_position%
good for searching for multiple matching
LEFT$(string$, n%) ... return the leftmost n% characters from string$
ex. PRINT LEFT$("hi, class", 4) ... gives "hi, "
RIGHT$(string$, n%) ... return the rightmost n% characters from string$
ex. PRINT RIGHT$("hi, class", 4) ... gives "lass"
MID$(string$, start%, n%)
... return n% characters from string$, starting at start%
ex. PRINT MID$("hi, class", 5, 2) ... gives "cl"
MID$("hi, class", 1) = "H" ... replace the 1st character with "H"
gives "Hi, class"
MID$("hi, class", 2) = "Go" ... gives "Go, class"
STRING$(n%, string$) ... generate string$ n% times
ex. PRINT STRING$(20, "*")
STRING$(n%, code%) ... generate string$ n% times
ex. PRINT STRING$(20, 64)
SPACES$(n%) ... generate n% blank spaces
LCASE$(string$) ... convert to lower case; good for case insensitive comparison
UCASE$(string$) ... convert to upper case; good for case insensitive comparison
ex. DO
resp$ = INPUT$(1)
LOOP WHILE UCASE$(resp$) = "Y"
MKI$ ... convert an integer to string
ex. New$ = MKI$(i%)
MKS$ ... convert a real variable to string
ex. New$ = MKS$(x!)
STR$ ... convert to string
ex. a$ = STR$(45) ... gives "45"
a$ = STR$(i%)
VAL("45") ... gives 45 (an integer)
ex. i% = VAL("45")
i% = VAL(string$)
r! = VAL("1.2")
ex. trick to ensure that the type is correct
INPUT "enter n: ", n$ | n%=VAL(n$)
------------------------------------------------------------------------------
Concatenation
A$ = "hi,"
B$ = " class"
C$ = A$ + B$ --> gives "hi, class"
C$ = C$ + A$ --> Add one character at a time
Integer division
7/3 --> 2.33333
7\3 --> 2
9.6\2.4 --> 5 (i.e., 10\2 because real numbers are round off before
operation is performed.)
Not very accurate (bugs?) 0.5\1 --> 0
but 1.5\1 --> 2
2.5\1 --> 2
3.5\1 --> 4
(Use int(x+0.5) to round off instead.)
7 MOD 3 --> 1
Precedence of Operations
same as FORTRAN
^ ... exponentiation; same as FORTRAN **
Assignment
same as FORTRAN
Logical Operators -- Boolean expression, condition
= ... .EQ. in FORTRAN
<> ... .NE.
> ... .GT.
< ... .LT.
>= ... .GE.
<= ... .LE.
0 ... .FALSE.
-1 ... .TRUE.
AND
OR
NOT()
e.g. false = 0000000000000000 (a value of 0)
true = 1111111111111111 (a value of -1) or any nonzero value
Variable type is the same as integer.
PRINT 1=1 ... gives -1
e.g., The following is very strange!!!
TRUE = 1
FALSE = NOT(TRUE) ... gives -2, not 0
ex. CONST FALSE = 0, TRUE = NOT FALSE ... good for readability or
imitating FORTRAN
ex. Two strings can be compared based on ASCII values ... good for sorting
------------------------------------------------------------------------------
-------------------------------------------------------------------------------
CONDITION, FLOW CONTROL
ELSEIF and ELSE part are optional
IF condition1 THEN -+ ... same as FORTRAN: + IF (condition1) THEN
statement1 | | statement1
ELSEIF condition2 THEN | | ELSEIF (condition2) THEN
statement2 | | statement2
ELSEIF condition3 THEN | | ELSEIF (condition3) THEN
statement3 | | statement3
ELSE | | ELSE
statement4 | | statement4
END IF -+ + END IF
------------------------------------------------------------------------------
SELECT CASE expression -+ ... same as FORTRAN:
CASE expression-list1 | + IF(expression .eq. expression-list1)THEN
statement1 | | statement1
CASE expression-list2 | | ELSEIF(expression .eq. expression-list2)THEN
statement2 | | statement2
: | | :
CASE ELSE | | ELSE
statement3 | | statement3
END SELECT -+ + ENDIF
Only the statements corresponding to the first match (not subsequent matches)
will be executed.
e.g. SELECT CASE i%
CASE 1, 3, 5, 7, j%, k%
PRINT "Odd"
CASE 2, 4, 6, 8
PRINT "even"
CASE ELSE
PRINT "Out of range"
END SELECT
e.g. SELECT CASE i%
CASE 1 TO 4, -4 TO -1 (must put the lesser value first)
statement
CASE IS >5
statement
END SELECT
e.g. CASE "abc" TO "bear" ... O.K.
CASE "abc" TO "Bear" ... no good (ASCII order is wrong)
e.g. CASE IShigh% ... multiple expressions
------------------------------------------------------------------------------
ON i% GOSUB 10, 20, 30, 40, 50
... goto 10 if i%=1, goto 20 if i%=2, goto 30 if i%=3 etc
... same as FORTRAN: GOTO (10, 20, 30, 40, 50) I
... unstructured; avoid
------------------------------------------------------------------------------
FOR i%=1 TO 5 + ... same as FORTRAN: + DO label icount=1, 5
statements | | statements
NEXT count% + + label CONTINUE
... The count variable may start with a negative integer.
... STEP other than 1 can be given.
... Infinite loop when STEP 0 is used. (This is not allowed in FORTRAN.)
FOR i%=5 TO 1 STEP -1 + ... same as FORTRAN: + DO label icount=5, 1, -1
statements | | statements
NEXT count% + + label CONTINUE
Forced exist from FOR ... NEXT loop
FOR i%=5 TO 1 STEP -1 + ... same as FORTRAN: + DO label icount=5, 1, -1
statements | | statements
EXIT FOR | | if( ... ) goto 101
statements | | statements
NEXT count% + + label CONTINUE
101 outside the loop
Counter is optional ...
ex. FOR count%=1 TO 5
statements
NEXT
Nesting ...
ex. FOR i%=1 TO 5
FOR j%=1 TO 10
statements
NEXT
NEXT
ex. FOR i%=1 TO 5
FOR j%=1 TO 10
statements
NEXT j%
NEXT i%
ex. FOR i%=1 TO 5
FOR j%=1 TO 10
statements
NEXT j%, i% (list the most inner counter first)
------------------------------------------------------------------------------
WHILE condition label IF (condition) THEN
statements statements
WEND ENDIF
GOTO label
------------------------------------------------------------------------------
Use EXIT DO within IF placed inside the loop to get out of the DO...LOOP
DO +
statements | infinite loop
IF .. THEN EXIT DO |
statements |
LOOP +
Test the condition first (thus, the statements in the loop may be completely skipped.)
DO WHILE condition + ... same as FORTRAN: + label IF (condition) THEN
statements | | statements
LOOP + | END IF
+ GOTO label
DO UNTIL condition + ... same as FORTRAN: + label IF (.not. condition) THEN
statements | | statements
LOOP + | END IF
+ GOTO label
Test the condition afterwards (thus, the statements in the loop are executed
at least once.)
DO +... same as FORTRAN: + label statements
statements | + IF (condition )GOTO label
LOOP WHILE condition+
DO +... same as FORTRAN: + label statements
statements | + IF (.not. condition)GOTO label
LOOP UNTIL condition+
------------------------------------------------------------------------------
INPUT/OUTPUT, FILES
PRINT
PRINT A; B -- the 2nd item is separated from the 1st by a space.
(May show 2 spaces between numbers because there is also a
space before the positive number.)
PRINT A, B -- the 2nd item is printed at the next tab position
(multiples of 14).
PRINT "A"; B --- the 2nd item is separated from the 1st string by 0 space.
(May show 1 space between the string and the number because
there is a space before the positive number.)
PRINT A; + combine output of several PRINT statements on the same line.
PRINT B +
PRINT A, + combine output of several PRINT statements on the same line.
PRINT B +
PRINT ... no argument ... print a blank line
PRINT "character strings"
PRINT logical expression
PRINT USING "###.###"; A ... 123.456 same as F7.3
PRINT USING "$$###.##"; A ... $123.45 (note two $ signs so that the $ sign is next to the number)
PRINT USING "#.###^^^^"; A ... 0.123E+03 same as E9.3
PRINT USING "+###"; A ... +123
PRINT USING "##_! = factorial of ## = ##,###.##"; 10; 10; 123.44 ("_!" gives "!")
... 10! = factorial of 10 = 123.44
fmt$ = "##_! = factorial of ## = ##,###.##" + same as the last line
PRINT USING fmt$; 10; 10; 123.44 +
PRINT "x("; i$; ") = "; using "##.#####^^^^"; x(i)
PRINT using "##.#####^^^^"; a, b, c ... repeat the same format
PRINT "a"; SPC(10); "b" ... skip 10 spaces between "a" and "b"
PRINT "a"; TAB(10); "b" ... print "b" on column 10
Other Output Statements
CLS
LOCATE row, column
LOCATE row, column, cursor ... cursor=1 ... visible
cursor=0 ... invisible
LOCATE row, column, cursor, start, stop
... start,stop=0..7 or 13 ... cursor size
| +Ä mono
+Ä color
e.g. LOCATE ,, 1, 0, 7 ... fill the whole space
LOCATE ,, 1, 0, 3 ... fill the top half
LOCATE ,, 1, 4, 7 ... fill the bottom half
LOCATE ,, 1, 6, 2 ... split cursor
WIDTH columns, rows
columns ... 40, 80
rows ... 25, 30, 43, 50, 60
VIEW PRINT topline TO bottom line
... only the portion between topline and bottom line is scrolled
... Use "CLS 2" to clear the text window
INPUT variable1, variable2 ... prompt with "?"
INPUT "prompt"; variable1, variable2 ... propmt with "prompt?"
INPUT "prompt: ", variable1, variable2 ... prompt with "prompt: "
same as + PRINT "prompt: ";
+ INPUT "", variable1, variable2
INPUT; "1st: ", v1 + appear on the same line
INPUT "2nd: ", v2 +
Because "," is used to separate input fields, enclose a string
variable input in " " if it contains ","; otherwise, use LINE INPUT.
LINE INPUT uses the same rules as INPUT, except that each line ended
with "Enter" is treated as one item.
LINE INPUT variable1, variable2
LINE INPUT #1, variable1, variable2
ex. PRINT "enter n: ";
LINE INPUT n%
Other Input functions
PRINT INPUT$(5) ... wait for 5 key strokes
a$ = INPUT$(5) ... read 5 key strokes (read all characters)
a$ = INPUT$(5, #1) ... read 5 key strokes (read all characters)
from #1
DO: LOOP WHILE INKEY$ = "" ... wait for a key press
ex. trap extended key combinations (e.g., INS key = HEX 52 = DEC 82)
DO: a$ = INKEY$: LOOP WHILE a$ = "" OR LEN(a$) < 2:
IF ASC(MID$(a$,2))=82 THEN command
ex. trap extended key combinations (same as above)
IF a$=MKI$(&H5200) THEN command
irow% = CSRLIN ... get cursor position -- row number
icol% = POS(idummy%) ... get cursor position -- column number
comparison ...
INPUT ... "," is the delimiter
LINE INPUT ... is the delimiter
INPUT$() ... no delimiter
OPEN "filename" FOR OUPUT AS #1 ... same as open(1,file='filename',status='new')
(existing file will be written over -- Be careful!)
OPEN "filename" FOR APPEND AS #1 ... append existing file
OPEN "filename" FOR INPUT AS #1 ... same as open(1,file='filename',status='old')
OPEN "filename" FOR RANDOM AS #1 ... random acess file
OPEN "filename" FOR BINARY AS #1 ... binary file
CLOSE #1 ... same as FORTRAN close(1)
KILL filespec ... same as DOS' "del filespec"
NAME filename1 AS filename2 ... same as DOS' "rename filename1 filename2"
ex. Automatically find the next file number with FREEFILE function
OPEN "file1" FOR INPUT AS #1
n% = FREEFILE
OPEN "file2" FOR INPUT AS #n%
INPUT #1, variable list
WRITE #1, variable list ... string variables enclosed in " ",
and field separated by "," in the file
PRINT #1, variable list ... the same as what one will see on screen
try to use WRITE/INPUT combinations
There is no easy way to write '"'. Do the following
q$ = CHR$(34)
PRINT q$; a$; q$
Steps in using a random acess file
1. Define a new type, i.e., new record structure
TYPE newtype
variable1 AS INTEGER
variable2 AS STRING*30
variable3 AS SINGLE
END TYPE
2. Declare a variable of new type
DIM RecordVariable AS newtype
2. Define the length of each field in a file
FIELD #1, 2 AS variable1, 30 AS variable2, 4 AS variable3
3. Open a file
OPEN "filename" FOR RANDOM AS #1 LEN = LEN(RecordVariable)
or
OPEN "filename" FOR RANDOM AS #1 LEN = 36
... calculate the record length by hand
record% = LOF(1) \ LEN(RecordVariable)
... find the number of record in the file
4. Read from or write to file
GET #1, record%, RecordVariable
GET #1, , RecordVariable ... move to the next record
PUT #1, record%+1, RecordVariable
PUT #1, , RecordVariable ... move to the next record
5. Each field in the record variable can be accessed individually
a% = RecordVariable.variable1
a$ = RecordVariable.variable2
a! = RecordVariable.variable3
6. Close file
CLOSE #1
A Binary I/O file
OPEN "filename" FOR BINARY AS #1
The following are the only ways to input from and output to a binary file.
INPUT$
GET #1, position%, RecordVariable
GET #1, , RecordVariable ... move to the next record
PUT #1, position%+1, RecordVariable
PUT #1, , RecordVariable ... move to the next record
SEEK #1, position%
i% = SEEK(1) ... returns position of next read/write
i% = LOC(1) ... returns position of last read/write
Device I/O
COM1: input and output
CONS: output only
KYBD: input only
LPT1: output only
SCRN: output only
ex. OPEN "LPT1:" for OUTPUT AS #1
------------------------------------------------------------------------------
SHELL "filename" ... transfer control to filename and execute it
ex. INPUT "Press 1 to execute file1"; resp$
SELECT CASE resp$
CASE "1"
SHELL "file1"
:
------------------------------------------------------------------------------
SUBROUTINES & FUNCTIONS
All variables are local by default.
A function/sub can call itself (recursive)
FUNCTION name (list of variables)
statements
EXIT FUNCTION
statements
name = ... ... must have this line
END FUNCTION
... Do not use old version: DEF FN ... END DEF (which uses global variables)
(Note: FN passes variables by value not reference)
... Use function in an expression
... Make sure the name matches with the type
(Try to identify the type of the function with a suffix: $, %, etc.
ex. DECLARE FUNCTION a%
... Arguments are not mandatory.
... Do not retrive the content from the variable with the function name
because QBasic gets confused with recursive functions
ex. name = name + 1
SUB name (list of variables)
statements
EXIT SUB
statements
END SUB
... do not use old version: GOSUB ... RETURN (which uses global variables)
Two ways of calling a subroutine
CALL sub_name (list of variables)
sub_name list of variables
... no parentheses
... must declare DECLARE SUB sub_name before use in the 2nd way
so that QBasic knows that it is not a variable
argument (when apearing in CALL)
parameters (when appearing in SUB)
... fixed-length string variable cannot be a parameter appearing in SUB
... array elements cannot be a parameter appearing in SUB
... type of the variable can be declared in the parameter list
ex. SUB abc(a AS INTEGER, b%)
passing an entire array ...
DIM a(1 TO 100) AS SINGLE
CALL name(a()) ... note the use of empty parentheses
:
SUB name (b() AS SINGLE)
passing individual array elements
DIM a(1 TO 100) AS SINGLE
CALL name(a(3))
:
SUB name (b)
passing records
+TYPE newtype1
| firstname AS STRING*10
| lastname AS STRING*5
|END TYPE
|DIM b AS newtype1
| :
|CALL name (b)
+SUB name (a AS newtype2)
passing elements in records
+TYPE newtype1
| firstname AS STRING*10
| lastname AS STRING*5
|END TYPE
|DIM b AS newtype1
| :
|CALL name (b.firstname, b.lastname)
+SUB name (a$, b$)
SUB|FUNCTION name (list of variables) STATIC
... make all variables used in the subroutine static
(i.e., they retain their values between calls)
... if only a select variable need to be made static, use STATIC statements:
ex. SUB a
STATIC i%
STATIC j%() AS INTEGER + AS INTEGER must appear in both statements
DIM j%(1 TO 5) AS INTEGER +
DECLARE FUNCTION or SUB in a module (not at the procedure level)
3 cases where DECLARE must be used:
Case 1:
DECLARE FUNCTION a(x!,y!) ... must declare
:
z! = a(x!,y!)
Case 2:
DECLARE SUB a(x!,y!) ... must declare if not used as CALL
: optional if use CALL
a x!, y!
Case 3:
DECLARE SUB a(x!,y!) ... must declare if SUB a is not included in
the same module
ex. DECLARE SUB a() ... use empty parentheses if no parameters
:
CALL a
ex. DECLARE SUB a(x AS newtype)... include type of variable
$INCLUDE is usually used for:
DECLARE statements
TYPE...END TYPE definitions
COMMON statements
Do not include function/subroutine definitions in an INCLUDE file.
Usage:
' $INCLUDE: 'filename'
passing arguments by reference
Address of the variable is passed. (default)
While in subroutine, the subroutine's corresponding variable uses the same
memory location as the variable in the calling statement.
ex. i% = 1
CALL a(i%)
PRINT i% ... gives 2
:
SUB a(j%)
j% = j%+1.
END SUB
passing arguments by value
The content of the variable in the calling statement is copied into another
memory location that corresponds to the variable in the subroutine.
Expression in the argument is always passed by value.
ex. CALL a(2+3)
To pass a variable by value, enclose it in parentheses (thus, QBasic
thinks that it is an expression).
ex. CALL a( (i%) )
ex. i% = 1
CALL a( (i%) )
PRINT i% ... gives 1
CALL a( i% )
PRINT i% ... gives 2
:
SUB a(j%)
j% = j%+1
END SUB
-------------------------------------------------------------------------------
METACOMMANDS
Metacommands ... begin with "$" and included in comments
ex. REM $STATIC
'$INCLUDE: 'file.bi' (Note: single quotes)
-------------------------------------------------------------------------------
Files ...
QB.INI ... save changes made to the Displays Dialog Box
BC file /o; ... compile
set lib=c:\qb ... path for BCOM45.LIB or BRUN45.LIB
BCOM45.LIB ... library needed to create a stand-alone program
BRUN45.LIB ... library needed to create an abbreviated program
BRUN45.EXE ... needed by the abbreviated program at run-time
(cannot be in \dpath)
Windows
Watch window
Help window
Immediate window (holds only 10 lines)
View window
Alt key to highlight menu items.
TAB key to switch between different windows or sections in a menu.
ESC key to cancel, get out of menu, or help
F1 key to get help on any item pointed by the cursor
Undo Alt+Backspace
Cut Block Shift+Del
Copy Block Ctrl+Ins
Paste Block Shift+Ins
Delete(Clear) Block Del
SUBs F2
Next SUB Shift+F2
Output Screen F4
Find Ctrl+\
Last Find F3
Start Run Shift+F5
Run/Continue F5
Step F8
Instant Watch Shift+F9
Toggle Breakoint F9
Help F1
Help on Help Shift+F1
Last Help Level Alt+F1
Switch Window F6 or Shift+F6
Expand window Ctrl+F10
Right word Ctrl+Right
Left word Ctrl+Left
Top Window Ctrl+Home
Bottom Window Ctrl+End
Last Page PgUp
Next Page PgDn
Left Page Ctrl+PgUp
Right Page Ctrl+Pgdn
mark block Shift-direction
Del char Ctrl-BS or Shift+BS
module ... same as FORTRAN: main program
procedure ... same as FORTRAN: subroutine/function
Only one module/proprocedure can be displayed each time.
View-SUBs ... shows a list of subroutines
Return to Prof. Nam Sun Wang's Home Page
Return to Computer Methods in Chemical Engineering (ENCH250)
Computer Methods in Chemical Engineering -- QuickBasic Summary
Forward comments to:
- Nam Sun Wang
- Department of Chemical Engineering
- University of Maryland
- College Park, MD 20742-2111
- 301-405-1910 (voice)
- 301-314-9126 (FAX)
- e-mail: nsw@eng.umd.edu
©1996-1999 by Nam Sun Wang
|
| |