QBASIC Programming

QBasic is a programming language, created by Microsoft.  It is based upon the original language BASIC (Beginners All-purpose Symbolic Instruction Code). In the early days of computers, most people wrote and ran their own programs. This led to the conclusion that everybody that was going to use a computer needed to learn how to program. Courses like "Computers and Society" were substantially about programming.
Now, however, it is clear that most people who use computers are not programmers, but use programs (applications) written by others; applications such as word processors, spreadsheets and database programs. Today, some of these can involve programming. Here, building formulae in Excel, and with the Paper and Pencil Computer, you have had some experience with programming. Even major word processors such as Microsoft Word contain built-in programming languages for customizing work; for example summing a column in a table as in the Ever Ripe document. Usually, however, anything substantial is done by specialists within an organization. In studying the impact of computers on society, it can still help to understand something about programming. But this is nowhere near the amount of programming that was done to create the applications.
What is a Computer Program?
A computer program is a list of instructions for a computer to execute. Programs come in several varieties:

• Programs that a computer can execute directly are in binary "machine language." These are called executable modules. Common extensions are exe, com, and dll. In this form, instructions have two parts, the operation code which says what action to take (addition, subtraction, load, store, print, etc.) and the address, which says which memory location to use. In machine language, both parts are in binary code. In the original Paper and Pencil Computer, STOP was 000, ADD was 001, SUB was 010 (counting in binary, of course), and so forth. Programming in machine language is very difficult and, for this reason, rare. Each type of (micro) processor has its own machine language, so that programs written for one processor are not compatible with other types.
• Slightly easier is "assembler," which uses mnemonic codes which the computer translates into binary codes. This is the case with the symbolic names STOP, ADD, SUB and the similar commands for the Paper and Pencil Computer. However, in full assembler language, memory addresses also have symbolic names, which the computer assigns to definite memory locations. Assembler language programs must be translated into machine language by the computer. Each type of (micro)processor has its own assembler language, so that programs written for one processor are not compatible with other types.
• Most programming is done using so-called "higher level languages" such as Basic, Fortran, Cobol and C. Here the statements are more like English, or at least algebra, and work more the way humans calculate, for example
  "x = a + b." Programs written in higher level languages also must be translated or compiled into machine language, but each type of processor has its own compiler for each computer language, so that programs written in higher level languages can be run on many different processors, by using that processor's compiler.
• The newest type of computer language is the so-called 4GL, for Fourth Generation Language such as C++ and Java. Programs in 4GL languages must also, of course, be translated or compiled into machine language, but here the programmer need not program exactly what the computer should do, but instead sets up "objects" and "methods" for objects to use when they interact.

With a standard higher-level program, there are two program files (and sometimes more): the file with the binary codes, also called "machine language," that the computer could execute (the "executable" file with the exe extension, but other variations are used in addition) and the "source file" with the English-like words. The programmer writes the source file, which usually has one instruction per line, and the computer translates that into the executable file, using a computer program that can be called either an "assembler" or "compiler." In this case, the entire program is translated into binary codes or machine language, and then executed all at once.
In an alternate scheme, there is only a source file, and the source file is compiled into machine language line by line, as it is executed (at “run time”). This is slower to execute, but for short programs it can be more convenient, and since computers are so fast today, can still run quickly in terms of human reaction times. In this case, the computer program that does the translation from source code to machine language is called an "interpreter." In the case of interpretation, the source program is translated into machine language line by line on the fly as it is executed, and there is no machine language file.
Here you will examine some pre-written programs to see how they work, using the QBASIC interpreted programming language. DOS always came with a built-in programming language. Earlier DOS versions came with GWBASIC, but later, QBASIC became the standard. Early versions of Windows came with a programming language, but starting with Windows 95, programming languages became for-sale add-ons.
Programming has several steps:

1. Design of the program (we will skip that step here, but in real-life programming it is critical, and often determines success or failure of the whole project).
2. Entering the program, usually via the keyboard. Programs are usually text files, although they may have extensions other than txt (QBASIC, for example, uses bas). However, even with other extensions, program files can be edited with text editors such as NotePad. The program at this point is in a programming language, and is generically known as "source code" (the form that can most easily be read and understood by humans.
3. Dubugging (easy part): fixing syntax problems. This is the easiest part of debugging. All programming languages have a grammar or syntax, that is formal rules that all statements must comply with. For example, in QBASIC, two variables must be separated by an operator that combines them, such as +, -, * (multiplication) or /. Each program statement must comply with the syntax, which means that the computer will be able to execute it. This by no means assures that the program will do what you want, however.
4. Debugging (hard part) execution. The source language statements must be translated into machine code that the computer can directly execute, either by compilation or assembly ahead of time, or by interpreting line-by-line as the program is run. QBASIC, again, uses the second method, interpretation. As the program is executed, the programmer must verify that the program is actually doing what was intended. This is also debugging, and is more difficult that the first step.

QBASIC is designed for small programs and quick results. It has one outstanding feature for beginners; each program line is checked for syntax after you leave the line with <Enter> or the up or down arrow keys. It may not do what you want, but the check ensures that it is legal. If the line is OK, it is put into a standard format with:

• all mathematical operators such as + and - have a space on each side
• all QBASIC commands and other keywords are capitalized. Examples of commands and keywords are INPUT (get user input from keyboard) and PRINT (display on the screen).

If the line is not legal, there is no change from the way you typed it; this is a signal to look for a problem and edit the line to fix the problem(s).
Notice that if you enter lines already in the standard format, there will be no change if the line is legal. Therefore, it pays to enter lines without spaces around the operators, and with the keywords in lowercase.

Starting up

Now if your so new that you don't even know where to put your code then read on, if you have
Qbasic all set up then skip to 'SECTION 2'.

Right, well you will need a Qbasic Interpreter, or the Compiler.  Try looking n the web for an
the QBasic .exe

OK, you have the .exe now so all you need to do is run it.  If you can run it simply by double clicking then good for you, if not then you have to use the DOS Command Line. If it all works then your screen should go blue and you have (more or less) a mouse cursor. This is where you put your code to run.  You can check whether you have got the interpreter or the compiler by clicking on the RUN menu, if you see a COMPILE option then you have compiler, if not then you have the interpreter.  It doesn't really matter which you have (not for my tutorials anyway).  The compiler is generally faster and allows you to make executable from your code.

OK then let’s get going on actually learning.

The first thing that I shall teach you is CLS.  What this does is clear the screen, it will make the screen blank, you can use this to clear text and graphics from the screen.

This is all fine and well, but as of yet you have nothing to clear from the screen. So what about learning PRINT this command can be used to make the computer write something on the screen, at first its name can be deceiving, but you'll understand later. So how do we use it?..  Its easy really, look at the following program:

CLS

‘Test

PRINT  "HELLO WORLD."

Lets step through:

First of all the CLS command will clear the screen.

Second we reach the PRINT command as you can see from the code the words 'HELLO WORLD. ' Are enclosed in speach marks.  This is how you use PRINT.

Try using PRINT to write other things on the screen, experiment with CLS and PRINT.

Writing words isn't the only thing that PRINT can do, it can do some math too.

Have a look at this:

CLS

PRINT "12 TIMES 12 IS:"

PRINT 12*12

'test

You should already know what the first two lines do so I will go on to the final line.  Most of you will be able to figure out what it does, but for those of you that can't its simple * means multiply so 12*12 means 12 multiplied by 12. And print will write the answer on the screen.

Print can do more, but I'll leave at this for the minute. Before I go I'll just tell you this, if you have just the word PRINT on its own, without any other words or numbers then it will just print a blank line and move onto the next. That’s all for this one.

VARIABLES

---------

Those of you with knowledge of algebra, science, etc. will know what a variable is.  A variable is a symbol(s) that holds a value, this could be numerical or text.  In QBASIC a variable is assigned a value to hold, this value can be anything.  You can tell what kind of thing a variable has from a symbol added on to the end. For the moment we will look at two of them the % (percent) sign and the $ (Doller) sign.  In QBasic they mean different things.  The % means an integer and the $ means string (text). variables don't have to have a sign on the end, these usually have a numerical value.

LET

A new command, LET this command is very useful it can assign a value to a variable:

'--------------------

LET A$ = "HELLO"

LET B$ = "WORLD."

'--------------------

This short program will assign the memory space 'A$' with the value of 'HELLO' and the space 'B$' with the value 'WORLD.' This is all fine and well but they're not much use to us like this.  We need to call back a command, previously taught in the first tutorial.  The PRINT command. Now, we know that PRINT can write words and numbers on the screen provided that they are typed with the syntax (a syntax is how a command is set out e.g. PRINT [words]) but it can also be used to print variables.  This is obvious when you think about it! Have a look at the following program:

CLS

LET A$ = "HELLO "

LET B$ = "WORLD."

PRINT A$ + B$

You will see that it simply an update to the first example, but how does it work? Well when you look at it you see that in fact you know how most of it works but what about the final PRINT statement? As you can see it doesn't use the speech marks.  PRINT substitutes the variables for their values and writes the result on the screen.  The + sign works differently to that of the mathematical +, in that in our example it joins the two variables together. The output of the program is this:

HELLO WORLD.

But 'OH MY' what happens when you actually want to ADD two numerical values together if the + sign is used to join them together!  Don't worry its easy, QBasic follows these rules when using the plus sign:

            If + is used between strings (text) then join them together.

            If + is used between numerical values then work as a mathematical operator.

            If + is used between a numerical value and a string then cause an error.

If all this was complicated then go back and read it over, also you could look through QBasic's help file for more information. Another type of joining symbol is the semi-colon (;) this one can join loads of things together, even a string and a number.

INPUT

This is another new command, that mixes PRINT, LET & Keyboard Inputs all together!

The best way to learn is to do, but how can you do something when you don't even know how to? Confused?  Well, anyway set your eyes on this:

CLS

INPUT "WHAT IS YOUR NAME"; N$

Let me explain the INPUT statement.  The first part of it (the "WHAT IS YOUR NAME" part) works just like the PRINT command so there's nothing complicated there.  However the last part is a bit different. In a way it’s similar to LET! Basically when you run the program you get the words WHAT IS YOUR NAME followed by a question mark.  You also get a curser added to the end; this allows you to enter words and numbers from the keyboard. Once you have typed in what you need press Enter and QBasic will assign the text you typed to the variable N$ (Just like LET).

Well, now that N$ has a value we could use PRINT to write it on the screen.  The program looks like this:

CLS

INPUT "WHAT IS YOUR NAME"; N$

PRINT N$

If you wanted you could put a CLS statement in between the INPUT and PRINT lines.

Whenever QBasic encounters an INPUT statement it stops execution and waits for a reply from the keyboard.

Now feast your eyes on this:

CLS

INPUT "WHAT US YOUR NAME"; NAME$

INPUT "HOW OLD ARE YOU"; AGE%

CLS

PRINT "HELLO " + NAME$

PRINT "YOU ARE" ; AGE% ; "YEARS OLD!"

By now should be able to understand this.  Remember the semi-colon and the + are used for joining and % means the variable type is an integer.

DIM

The first thing I'm going to teach you is DIM this can be very useful when using variables. For example, say you had a program that required 500 variables all based on the same thing, lets say 500 names in an address book, and you don't want to have to type out 500 different variables. Ever since the beginning of computer programming, programmers have tried to find quicker and easier ways to do something.  This is one of them. DIM can be used to create loads of variables in just one command.  It works like this:

DIM NAMES$ (500)

This an 'array' of names from 0 to 500 (so 501 different variables made here)

To give one of the variables a value does the following:

LET NAME$(5) = "OLD MAN"

This will give the 6th variable the value 'OLD MAN' (Remember that zero counts as a variable) Well that wasn't too hard now was it.  So this should be a breeze:

DIM NAME$ (500)

LET N% = 5

LET NAME$(5) = "OLD MAN"

CLS

PRINT NAME$(N%)

The number that is used with an array can be a variable too; this is shown in the program above. The output from the program should be obvious:   OLD MAN As an array can be called using a variable this means that you can create nested arrays:

DIM NAME$ (500)

DIM NUM% (10)

LET N% = 4

LET NUM%(4) = 5

LET NAME$(5) = "OLD MAN"

CLS

PRINT NAME$(NUM(N%))

If you don't understand this straight away then don't worry just read over it few times, I'm sure you'll get it. Arrays are usually defined at the beginning of a program, or at least before they are used.

GOTO

This is a can be a useful statement, it is used to make the program execution move to another location in the program. To use GOTO you have to fisrt of all make a 'tag' for the program to jump to.

CLS

PRINT "WHAT A NICE DAY"

GOTO COMEHERE

PRINT "GOODBYE 1"

COMEHERE:

PRINT "GOODBYE 2"

As you can see a 'tag' must have a colon at the end. When run you should get this output:

WHAT A NICE DAT

GOODBYE2

This is because the GOTO moves or jumps to the tag and continues from there.  You must not have two tags with the same name.  Tags are used by GOTO as a 'look up' spot, when they encountered during normal execution they are simply ignored. It is possible to make and endless loop using goto, look:

CLS

START:

PRINT "HELLO"

GOTO START

This program will go on forever, in an endless loop.  To stop it press CTRL & Break buttons to stop the program manually. Well that’s all there is to know about GOTO!

Let’s move onto GOSUB

GOSUB

GOSUB works similar to GOTO but with one difference, have a look at this:

CLS

PRINT "WHAT A NICE DAY"

GOSUB COMEHERE

PRINT "GOODBYE 1"

END

COMEHERE:

PRINT "GOODBYE 2"

RETURN

This program introduces you to two new commands, the END command and the RETURN command. END is a basic command which does exactly what it is called it will cease execution regardless of whether there is still more code or not. The RETURN statement is used with GOSUB to return to the line AFTER the initial GOSUB.

So the output is:

WHAT A NICE DAY

GOODBYE 2

GOODBYE 1

Have a go practicing what you have learnt so far.

FOR...NEXT

This is actually two statement, FOR and NEXT. These are used to make a different type of loop. Look at the following example:

FOR N% = 1 TO 20

CLS

PRINT "HELLO WORLD ";N%

NEXT N%

This program will look around 20 times. The FOR statement sets up a loop, this stuff directly after is a test, the variable N% is used, and every time the program loops it is incremented by 1 and once it reaches 20 the loop breaks and continues with the rest of the program. This is another example of this type of loop

FOR X = 1 TO 100

            FOR Y = 1 TO 100

                        CLS

                        PRINT "X:";X

                        PRINT "Y:";Y

            NEXT Y

NEXT X

This example uses nested loops and the values are printed on the screen.  This type of program could be used for graphics where a pixel is made to draw a line. I have also used tabs to tidy up my program, in long programs tabs can make the code easier to read.

When this program is run you will find the text written on the screen flashes a lot, this is

Because the CLS is constantly clearing the screen, an improvement on this program is this:

FOR X = 1 TO 100

            FOR Y = 1 TO 100

                        LOCATE 1,1

                        PRINT "X:";X

                        PRINT "Y:";Y

            NEXT Y

NEXT X

The LOCATE statement can be used to set the location of a PRINT statement, the first value is the row number and the second is the column number.  Using this method also increases the speed of the execution. Try to get to grips with FOR..NEXT loops, GOTO, GOSUB, LOCATE, etc. they can be very powerful tools when making larger, more implicated programs.

Let’s begin with some loops stuff.  You should already now about using GOTO, GOSUB and FOR..NEXT statements but what about DO..LOOP or WHILE...WEND?

I don't often use the WHILE..WEND statements but I'll teach you them anyway.

The WHILE..WEND statements are similar to the FOR..NEXT loop but with a few differences.  Take a look at this:

WHILE N < 100

PRINT N

N=N+1

WEND

The program above will loop around 'while' N < 100 once the variable reaches the set number it will stop looping and continue as normal. That's all there is to know about WHILE...WEND, here is a different type of loop, very much like the one just shown.

DO...LOOP

These are very much similar as to the ones above but have better control with them. 

DO

PRINT N

N=N+1

LOOP UNTIL N = 100

The program above will do exactly the same thing as the previous one it has just been set out differently.  The DO...LOOP statements can not only use the UNTIL command but also the WHILE.

DO

PRINT N

N=N+1

LOOP WHILE N < 100

Notice that on the bottom line the same syntax has been rewritten to do exactly the same thing! It usually doesn’t matter which one you use. With the DO...LOOP method you don't have to but the test on the bottom line (e.g.  The line with the word LOOP) you could put it on the the DO line. 

DO

PRINT N

N=N+1

LOOP UNTIL N = 100

DO UNTIL N = 10

PRINT N

N=N+1

LOOP

One other thing about loops is that if you don't have a test then the loop will continue forever! Well now you're a master of loops!  Practice using what you know to make your own programs too.

IF..THEN..ELSE

An IF statement or 'statement block' can be used to evaluate variables or other things and execute code based on the result. Look at this IF statement and try to guess how it works:

CLS

LET N = 5

IF N = 5 THEN PRINT "N IS 5"

IF N = 10 THEN PRINT "N IS 10"

The program starts off by making the variable N the value of 5 The following two statements are IF's  they perform tests on the variable and execute a command as required.  The output from this would be 'N IS 5' you can see why, I won't bother explaining. IF's can also make more complex lines:

CLS

LET N = 5

IF N = 5 THEN PRINT "N IS 5" ELSE PRINT "N IS NOT 5"

This program is similar to the one above but on the line with the IF an extra piece has been added on 'ELSE PRINT "N IS NOT 5" ‘ This piece is executed if and only if N doesn't equal 5. Take a look at this example:

CLS

LET NAME$ = "DAVID"

IF NAME$ = "JANE" THEN PRINT "HI JANE" ELSE PRINT "NICE DAY?!"

When you run this program the output is 'NICE DAY?!'  the 'HI JANE' part is not shown because NAME$ is not equal to 'JANE'. Now onto statement blocks.  These do exactly the same as what you've just seen except they can execute more than just one statement:

CLS

LET NAME$ = "DAVID"

IF NAME$ = "DAVID" THEN

            PRINT "HI THERE"

            PRINT "DAVID"

END IF

Notice the END IF?  This tells the computer that all the code enclosed within the IF and the END IF is to be executed when the test is TRUE and that it should not be executed otherwise. You can also add the ELSE command into a statement block:

CLS

LET NAME$ = "DAVID"

IF NAME$ = "DAVID" THEN        

            PRINT "HI THERE"

            PRINT "DAVID"

ELSE

            PRINT "NICE DAY?!"

END IF

Using what you have learnt already you should be able to see how this works.  Here's a hint the final output is:

HI THERE

DAVID

Practice using IF statements and statement blocks, they can be very powerful.  Also in larger programs try to use tabs they can help in decoding and for later review.

SELECT CASE

This is another way of testing things.  SELECT CASE statement blocks can be used for branching and be used to replace IF's when a single variable can have many different results. Take a look at another example:

CLS

FOR N = 1 TO 5

            SELECT CASE N

                        CASE 1

                                    PRINT "MONDAY"

                        CASE 2

                                    PRINT "TUESDAY"

                        CASE 3

                                    PRINT "WEDNESDAY"

                        CASE 4

                                    PRINT "THURSDAY"

                        CASE 5

                                    PRINT "FRIDAY"

            END SELECT

NEXT N

You should already know what the FOR and CLS do so I'll go straight onto the SELECT CASE. Some of you may already be able to see what it does, but I'll tell you anyway.

The first line SELECT CASE N tells the computer to take out a notepad and get ready for some experiments on the variable N. The next line CASE 1  can be translated into an IF statement so.. IF N = 1 THEN .....

Anyway, the line(s) directly below that are what are executed if this is true.

This is the same for the other 'CASE ' lines. The END SELECT line means stop testing.  Simple! A different type of CASE line can be added, this is CASE ELSE.  It is the same as an IF's ELSE statement.  If we put this in the program above we have:

CLS

FOR N = 1 TO 7

            SELECT CASE N

                        CASE 1

                                    PRINT "MONDAY"

                        CASE 2

                                    PRINT "TUESDAY"

                        CASE 3

                                    PRINT "WEDNESDAY"

                        CASE 4

                                    PRINT "THURSDAY"

                        CASE 5

                                    PRINT "FRIDAY"

                        CASE ELSE

                                    PRINT "SATURDAY - SUNDAY"

            END SELECT

NEXT N

Branching like what you've just been shown can be extremely useful in replacing loads of IF's! That's not to say that you can just use SELECT CASE instead of IF.

QBASIC Functions and Statements

 

Functions and Statements

ABS Function

APPEND

ACCESS

AS

ALIAS

ASC Function

AND Operator

ATN Function

ANY

BASE

BLOAD Statement

BASIC Program Lines

BSAVE Statement

BEEP Statement

BYVAL

BINARY

CALL Statement

CLS Statement

CALLS Statement

COLOR Statement

CALL ABSOLUTE Statement

COM Statement

CALL INTERRUPT Statement

COMMAND$ Function

CASE

COMMON Statement

CDBL Function

CONST Statement

CDECL

COS Function

CHAIN Statement

CSNG Function

CHDIR Statement

CSRLIN Function

CHR$ Function

CVD Function

CINT Function

CVDMBF Function

CIRCLE Statement

CVI Function

CLEAR Statement

CVL Function

CLNG Function

CVS Function

CLOSE Statement

CVSMBF Function

DATA Statement

DEFINT Statement

Data Types

DEFLNG Statement

DATE$ Function

DEFSNG Statement

DATE$ Statement

DEFSTR Statement

DECLARE (BASIC) Statement

DIM Statement

DECLARE (Non-BASIC) Statement

DO...LOOP Statement

DEF FN Statement

DOUBLE

DEF SEG Statement

DRAW Statement

DEFDBL Statement

$DYNAMIC Meta command

ELSE

ERDEV Function

ELSEIF

ERDEV$ Function

END Statement

ERL Function

ENDIF

ERR Function

ENVIRON Statement

ERROR Statement

ENVIRON$ Function

EXIT Statement

EOF Function

EXP Function

EQV Operator

Expressions and Operators

ERASE Statement

FIELD Statement

FOR...NEXT Statement

FILEATTR Function

FRE Function

FILES Statement

FREEFILE Function

FIX Function

FUNCTION Statement

GET (File I/O) Statement

GOSUB Statement

GET (Graphics) Statement

GOTO Statement

HEX$ Function

IF...THEN Statement

INPUT$ Function

IMP Operator

INSTR Function

$INCLUDE Meta command

INT Function

INKEY$ Function

INTEGER

INP Function

IOCTL Statement

INPUT Statement

IOCTL$ Function

INPUT # Statement

IS

KEY Statement

KILL Statement

KEY(n) Statement

LBOUND Function

LOCATE Statement

LCASE$ Function

LOCK...UNLOCK Statements

LEFT$ Function

LOF Function

LEN Function

LOG Function

LET Statement

Logical Operator Truth Table

LINE (Graphics) Statement

LONG

LINE INPUT Statement

LOOP

LINE INPUT # Statement

LPOS Function

LIST

LPRINT Statements

LOC Function

LSET Statement

LOCAL

LTRIM$ Function

MID$ Function

MKL$ Function

MID$ Statement

MKS$ Function

MKD$ Function

MKSMBF$ Function

MKDIR Statement

MOD

MKDMBF$ Function

Modules and Procedures

MKI$ Function

NAME Statement

NOT Operator

NEXT

OCT$ Function

ON UEVENT Statement

OFF

ON...GOSUB Statement

ON

ON...GOTO Statement

ON COM(n) Statement

OPEN (File I/O) Statement

ON ERROR Statement

OPEN COM Statement

ON event Statements                Operator Precedence Rules

ON KEY(n) Statement

OPTION BASE Statement

ON PEN Statement

OR Operator

ON PLAY(n) Statement

OUT Statement

ON STRIG(n) Statement

OUTPUT

ON TIMER(n) Statement

PAINT Statement

POINT Function

PALETTE Statements

POKE Statement

PCOPY Statement

POS Function

PEEK Function

PRESET Statement

PEN Function

PRINT Statement

PEN Statement

PRINT USING Statement

PLAY(n) Function

PRINT # Statement

PLAY (Music) Statement

PSET Statement

PLAY (Event Trapping) Statements

PUT (File I/O) Statement

PMAP Function

PUT (Graphics) Statement

RANDOM

RETURN Statement

RANDOMIZE Statement

RIGHT$ Function

READ Statement

RMDIR Statement

REDIM Statement

RND Function

REM Statement

RSET Statement

RESET Statement

RTRIM$ Function

RESTORE Statement

RUN Statement

RESUME Statement

SADD Function

SPC Function

SCREEN Function                    SQR Function

SCREEN Statement

STATIC Statement

SEEK Function

$STATIC Meta command

SEEK Statement

STEP

SELECT CASE Statement

STICK Function

SETMEM Function

STOP Statement

SGN Function

STR$ Function

SHARED Statement

STRIG Function

SHELL Statement

STRIG Statements

SIGNAL

STRING

SIN Function

STRING$ Function

SINGLE

SUB Statement

SLEEP Statement

SWAP Statement

SOUND Statement

SYSTEM Statement

SPACE$ Function

TAB Function

TIMER Statement

TAN Function

TO

THEN

TROFF Statement

TIME$ Function

TRON Statement

TIME$ Statement

TYPE Statement

TIMER Function

UBOUND Function

UNLOCK Statement

UCASE$ Function

UNTIL

UEVENT Statement

USING

VAL Function

VARSEG Function

Variable Scope Rules

VIEW (Graphics) Statement

VARPTR Function

VIEW (Text) Statement

VARPTR$ Function

WAIT Statement

WINDOW Statement

WEND

WRITE (Screen I/O) Statement

WHILE...WEND Statement

WRITE (File I/O) Statement

WIDTH Statements

XOR Operator