Chapter 1 – Here's Some Source Code

InternetBasic is a very easy programming language to learn. But, don’t be fooled – it’s also a very powerful programming language. Through the course of this book, you will discover why both of these statements are true.

In this chapter, we’re going to look at some very simple code. All of the sample programs mentioned in this chapter perform text input/output in the InternetBasic client window. (Other types of screen I/O – such as web pages, Windows controls, and dialog boxes – are explained in later chapters.)

This chapter contains the source code for several sample IB programs. In the first example, every instruction is explained in detail. In the subsequent examples, only the major features are described. By studying the code (including the comments in the source programs), you will see how easy it is to understand this language. All of these samples are contained on the enclosed compact disc. We invite you to study these programs, compile them using the free IB compiler, and run them using the free IB runtime system.

Every programming language has rules. Here's the most important rule for IB programs:

IB source programs consist of two sections. The first section contains definitions of the data for the program, such as variable names, sizes, and types. The second section contains the executable code.

Here's what this looks like:

Data section

Code section

The data section of the program contains information about the data you want to use in the code section. You need to decide a few things before you define each data field, including these questions:

1. How many characters will be stored in each data field?

2. What names will be chosen for each field?

3. Will this data field be used in one program only, or in a series of programs that are run one after another (such as overlays and subprograms)?

For example, suppose you want to define a data field to store a phone number. Here are some possible answers for the above questions:

1. The phone number field will be 20 characters (an arbitrary value for the sake of this example).

2. Let's name this field PHONE$ (the trailing $ means that it's a string field, not a numeric one)

3. Let's use this field in one program only.

As a result of these choices, we can write the following information in the data section of the source program:

LENGTH 20

LOCAL PHONE$

The first statement means that we're defining a string field width a length of 20 characters. The second statement means we're defining a field named PHONE$ that will be used in one program only (LOCAL).

(See Chapter 2 for some more information about the data section.)

Once the data section has been written, you can write some executable code. Using the phone number field from above, here are a few examples of IB executable code:

Code Description

PHONE$ = "(555) 555-5555" Assign a specific value to PHONE$

INPUT PHONE$ Input a value from the keyboard

PRINT PHONE$ Print (display) the value of PHONE$

Let's look at a complete IB program. The following source program shows the data section and code section for a program that converts between the Fahrenheit and Celsius temperature scales. The data section contains four data fields, and the code section contains instructions that accept input data from the keyboard, process the data, and display the results on the screen.

Here's the source code:

! Define the variables

LENGTH 6.2

LOCAL Fahrenheit,Celsius

LENGTH 1

LOCAL Choice$,Answer$

! Here's the code

Top: Print (CS)

Print "This program converts between temperature scales." , @(0,3)

Print "Enter 1 to convert from Fahrenheit to Celsius, or" , @(0,5)

Print "enter 2 to convert from Celsius to Fahrenheit." , @(0,6)

Choice:

Print "Your choice?" , @(0,8)

Input @(14,8),Choice$

SELECT CASE Choice$

CASE ""

STOP

CASE "1"

Print "Enter Fahrenheit temperature:" , @(0,10)

Input @(30,10),Fahrenheit

Celsius = (Fahrenheit - 32) / 1.8

Print "Celsius temperature is:",@(0,12) ; Celsius,@(30,12)

CASE "2"

Print "Enter Celsius temperature:" , @(0,10)

Input @(30,10),Celsius

Fahrenheit = Celsius*1.8 + 32

Print "Fahrenheit temperature is:",@(0,12) ; Fahrenheit,@(30,12)

CASE ELSE

Print "Please enter 1 or 2." , @(0,10)

GOTO Choice

ENDSELECT

Print "Would you like to perform another conversion? (Y/N)" , @(0,14)

Input @(52,14),Answer$

Answer$ = UCASE(Answer$)

IF Answer$ = "Y" THEN

GOTO Top

ELSE

STOP

ENDIF

END

Here's what the screen looks like when this program is run. In this case, the user chose option 1 (to convert from Fahrenheit to Celsius), and then entered 212 as the Fahrenheit temperature. The program converted this value and displayed the answer.

This program converts between temperature scales.

Enter 1 to convert from Fahrenheit to Celsius, or

enter 2 to convert from Celsius to Fahrenheit.

Your choice? 1

Enter Fahrenheit temperature: 212.00

Celsius temperature is: 100.00

Would you like to perform another conversion? (Y/N) __

Here's another run of the program. This time the user chose option 2, and then entered a Celsius value of 37. The program converted this to Fahrenheit and displayed the answer.

This program converts between temperature scales.

Enter 1 to convert from Fahrenheit to Celsius, or

enter 2 to convert from Celsius to Fahrenheit.

Your choice? 2

Enter Celsius temperature: 37.00

Fahrenheit temperature is: 98.60

Would you like to perform another conversion? (Y/N) __

Here’s a line-by-line explanation of the temperature conversion program:

! Define the variables

This is a comment. When the IB compiler sees an exclamation mark (!) it ignores the remainder of the source line. (The only exception to this rule is when an exclamation mark appears inside of quotation marks, in which case the IB compiler treats as part of a character string.)

LENGTH 6.2

This is the first line in the data section of the program.

LENGTH 6.2 means that this program is going to have one or more numeric variables with a length of 6 digits and a precision of 2 digits. Such variables can store values from –9999.99 to 9999.99, inclusive.

Note: IB numeric variables can store a maximum length 16 digits and a maximum precision of 15 digits. For example, LENGTH 16.2 defines a 16-digit variable with 2 of those digits to the right of the decimal point.

LOCAL Fahrenheit,Celsius

There are the numeric variables, appropriately named Fahrenheit and Celsius. (Since this statement appears after a LENGTH 6.2 statement, these variables are created with a length of 6 digits and precision of 2 digits.)

LOCAL means that these variables are used in this program only. (In later examples we will describe the other classification for variables, which is COMMON.)

LENGTH 1

This defines one or more string variables with a size of 1 character.

Note: IB string variables can store a maximum of 254 characters. For example, LENGTH 100 defines a 100-character string variable, while LENGTH 254 defines a 254-character string.

LOCAL Choice$,Answer$

The string variables are named Choice$ and Answer$. As with the numeric variables defined above, these variables are defined as LOCAL, meaning they are used in this program only.

! Here's the code

This is another comment. The IB compiler ignores this line when the program is compiled.

Top: Print (CS)

This is the first line in the code section of the program.

This line includes a statement label (Top:) that is referred to by a subsequent statement in the program. The Print statement is one of the output statements in IB. The (CS) control code clears the screen in the IB client window.

Print "This program converts between temperature scales." , @(0,3)

Print "Enter 1 to convert from Fahrenheit to Celsius, or" , @(0,5)

Print "enter 2 to convert from Celsius to Fahrenheit." , @(0,6)

These Print statements display text in the IB client window. The first message is displayed starting at column 0, row 3 (Note: column 0, row 0 is the upper, left-hand character position on the IB client screen.) The second and third messages are displayed on rows 5 and 6, respectively.

Note: The positioning parameter is separated from the text by a comma. The space on either side of the comma is optional.

Choice:

This is a statement label that is referred to by a subsequent statement in this program.

Note: A statement label can appear on a line by itself (as shown here) or on a line with executable code (as shown in the Top statement label earlier in this program).

Print "Your choice?" , @(0,8)

This statement displays a message (a prompt) starting at column 0, row 8.

Input @(14,8),Choice$

This statement moves the cursor to column 14, row 8, and creates a one-character space on the screen. This space is an input field where the user types a value. When the user types a value and presses the Enter key, that value is assigned to the string variable named Choice$.

Note: The Input statement creates a space equal to the length of the variable. In this case, the Choice$ variable has a length of 1 character, so the input field is created with a length of 1 character.

SELECT CASE Choice$

This section of the program evaluates one or more values of Choice$. The first statement in this structure, SELECT CASE Choice$, identifies the variable that is examined in the subsequent statements. The structure ends with the ENDSELECT statement.

CASE ""

STOP

CASE lists a specific value of Choice$ to be evaluated. In these lines of code, the value is null (indicated by the double quotation marks). When a user presses the Enter key at an Input statement without typing a data value, IB sees this as a null string. This program assumes that this event means that the user wants to quit the program, so the STOP statement is executed.

CASE "1"

The next four lines in this program are executed only if Choice$ equals “1”. (According to the messages displayed on the screen at the beginning of the program, the user enters “1” to convert from Fahrenheit to Celsius.)

Print "Enter Fahrenheit temperature:" , @(0,10)

Input @(30,10),Fahrenheit

The Print statement displays a message at column 0, row 3. The Input statement creates an input space for the Fahrenheit variable at column 30, row 3. Since this variable has been defined with a length and precision of 6.2, the input field is 8 characters wide (6 for the digits, one for a possible decimal point, and one for a possible minus sign).

Celsius = (Fahrenheit - 32) / 1.8

This one is easy. The code converts the Fahrenheit temperature and assigns the answer to the variable named Celsius.

Print "Celsius temperature is:",@(0,12) ; Celsius,@(30,12)

Now we’ll display a message at column 0, row 12, followed by the Celsius variable at column 30, row 12.

CASE "2"

The next four lines in this program are executed only if Choice$ equals “2”.

Print "Enter Celsius temperature:" , @(0,10)

Input @(30,10),Celsius

Fahrenheit = Celsius*1.8 + 32

Print "Fahrenheit temperature is:",@(0,12) ; Fahrenheit,@(30,12)

This is starting to look familiar. We display a message starting at column 0, row 10, then create an input space at column 30 for the Celsius variable. Next the code converts the Celsius value to Fahrenheit. Finally we display a message and the Fahrenheit value on row 12.

CASE ELSE

Print "Please enter 1 or 2." , @(0,10)

GOTO Choice

Here’s how we deal with the person who typed something other than “1” or “2” at the Input statement. The CASE ELSE statement is located after the other CASE sections, and handles all other values that are entered for Choice$. In our program, we’re going to display a warning message starting at column 0, row 10, and then jump back to the statement label Choice (the place where we displayed the first question in this program).

ENDSELECT

We’re done with the SELECT structure.

Print "Would you like to perform another conversion? (Y/N)" , @(0,14)

Input @(52,14),Answer$

Let’s give the user the option to try another temperature conversion. First we’ll display a message starting at column 0, row 14. Then we’ll create a one-character input field at column 52, row 14 for the Answer$ variable.

Answer$ = UCASE(Answer$)

The UCASE function turns the user’s response into an upper case value. This function lets us evaluate the answer using less code (i.e., we don't need to check for a lower-case response).

IF Answer$ = "Y" THEN

GOTO Top

ELSE

STOP

ENDIF

This is another type of decision structure, one the shows how the IF statement works. The structure starts by testing to see if Answer$ is equal to upper case “Y” (thanks to the UCASE function from above). If so, the program jumps back to the statement label Top (which is the beginning of the code section in this program).

If Answer$ is not equal to “Y” the program stops.

END

This optional statement tells the IB compiler that it has reached the end of the source program. (Note: This is not an executable statement; it's just a way to tell the compiler to stop compiling our code.)

Now that you've looked at the source code, try running the compiled object program. The program is named SAMPLE1.

Instructions:

From the InternetBasic READY prompt, type SAMPLE1 and press the Enter key.

Take a look at the source program. The source program is named SAMPLE1.MTB.

Instructions:

??? (WinEdit)

Now try compiling this program.

Instructions:

??? (compiling from WinEdit)

You probably noticed that the beginning part of the source program contains a command we haven't discussed yet:

! //MTB// Src(SAMPLE1.MTB,BAS) Obj(SAMPLE1,BAS)

This is the scripting command for the IB compiler, and it defines the name and location of the source and object programs. In this case, the source program is named SAMPLE1.MTB and the object program is named SAMPLE1. Both files are located on the BAS directory.

Notice that the scripting command starts with an exclamation mark, the comment character in IB. Thus, the compiler does not attempt to compile these lines as part of the program itself. Instead, the compiler reads this lines and, since it is at the beginning of the source code, treats it as a script command.

All of the other IB sample programs in this book contain similar scripting commands. Let's look at a few of those samples.

SAMPLE2

This program does a simple business calculation based on three data values. The break-even point tells a business how many units must be sold in order to break even. The calculation divides the organization's fixed cost (also known as “overhead”) by the difference between the selling price and cost of a single item.

Here's what the screen display looks like for a sample set of data.

This program computes the break-even point.

What is the selling price? 5.37

What is the cost? 4.65

What is the fixed cost (overhead)? 12000.00

The break-even point is: 16667 units

View revenue & expense details? (Y/N) y

Break-even details

Revenue: 89501.79

Expenses: 89501.55

Profit: .24

Another calculation? (Y/N)

The source program is named SAMPLE2.MTB. Notice that the source program contains several comments that explain the IB statements.

! //MTB// Src(SAMPLE2.MTB,BAS) Obj(SAMPLE2,BAS)

! Define the variables

! Numeric variables with 2 digits precision

LENGTH 6.2

LOCAL Price,Cost

LENGTH 10.2

LOCAL FixedCost,Temp,Revenue,Expenses,Profit

! Numeric variable with 0 digits precision (i.e., an integer)

LENGTH 6.0

LOCAL BreakEvenPoint

! String variable with length of 1

LENGTH 1

LOCAL Answer$

! Here's the code

Top: Print (CS)

! Display opening message

Print "This program computes the break-even point." , @(0,3)

! Display prompts and input data

Print "What is the selling price?" , @(0,5)

Input @(39,5),Price

Print "What is the cost?" , @(0,6)

Input @(39,6),Cost

Print "What is the fixed cost (overhead)?" , @(0,7)

Input @(35,7),FixedCost

! Calculate the temporary answer

Temp = FixedCost / (Price - Cost)

! If the fractional portion of the temporary answer is more

! than zero, increment the break-even point up to the next integer

IF FPT(Temp) > 0 THEN

BreakEvenPoint = Temp + 1

ELSE

BreakEvenPoint = Temp

ENDIF

! Display the answer

Print "The break-even point is:" , @(0,9)

Print BreakEvenPoint , @(36,9) ; "units"

! Display prompt and input answer

Print "View revenue & expense details? (Y/N)" , @(0,12)

Input @(38,12),Answer$

! Convert the answer to upper case

Answer$ = UCASE(Answer$)

! If the answer is "Y" then calcuate and display details

IF Answer$ = "Y" THEN

Revenue = Price * BreakEvenPoint

Expenses = Cost * BreakEvenPoint + FixedCost

Profit = Revenue - Expenses

Print "Break-even details",@(0,14)

Print "Revenue:",@(0,15) ; Revenue,@(35,15)

Print "Expenses:",@(0,16) ; Expenses,@(35,16)

Print "Profit:",@(0,17) ; Profit,@(35,17)

ENDIF

! Display prompt and input answer

Print "Another calculation? (Y/N)" , @(0,20)

Input @(28,20),Answer$

! Convert the answer to upper case

Answer$ = UCASE(Answer$)

! If the answer is "Y" then go back to the top

IF Answer$ = "Y" THEN

GOTO Top

ELSE

STOP

ENDIF

END

SAMPLE3

This program plays a number guessing game. The program picks a random number between 1 and 100, and you have to guess the answer. You have up to 16 chances to get the right answer.

Run the program first, and then look at the code.

The source program is named SAMPLE3.MTB. The source program contains several comments that explain the IB statements.

This program contains some IB features that we haven't covered yet. Here's a brief overview:

1. The RND function generates a random number. There are two forms of this function. The RND(1) version “randomizes” the generator, so you'll get a different random number sequence each time you run this program. The RND(0) function generates a random number between 0 and 1. This value is scaled to the appropriate range by a simple formula.

2. The positioning parameter in the Print statement contains a variable for the row number.

3. The STR function converts a number into a string.

4. The STRIP function strips leading and trailing blanks from a string.

5. Many of the CASE statements in this program contain multiple values, separated by semicolons.

Here’s the source code:

! //MTB// Src(SAMPLE3.MTB,BAS) Obj(SAMPLE3,BAS)

! Define the variables

! Numeric variables

LENGTH 3.0

LOCAL Number,Guess,Counter,Row

! String variables

LENGTH 3

LOCAL Number$,Counter$

LENGTH 1

LOCAL Answer$

! Here's the code

Number = RND(1) ! Randomize

Top: Print (CS) ! Clear the screen

CLEAR ! Initialize all of the variables

! Get random number between 1 and 100

Number = RND(0)*100 + 1

! Display opening message

Print "Number Guessing Game" , @(0,0)

Print "--------------------" , @(0,1)

Print "I am thinking of a number between 1 and 100." , @(0,3)

! Display prompt and input data

Print "What is your first guess?" , @(0,5)

FirstGuess: Input @(30,5),Guess

! Validate the input. If out of range, try again.

IF Guess LT 1 OR Guess GT 100 THEN

GOTO FirstGuess

ENDIF

! Set row number to 5

Row = 5

Evaluate:

! Increment the counter (keep track of the number of guesses)

Counter = Counter + 1

! If the counter = 16, stop the game

IF Counter = 16 THEN

Row = Row + 2

Print "Sorry, you only get 16 chances.",@(0,Row)

Number$ = STRIP(STR(Number)) ! Strip blank spaces

Print " The number was " ; Number$ ; "."

GOTO PlayAgain

ENDIF

! See if the guess is correct, too high, or too low

SELECT CASE Guess

GotIt: ! They got the right number

CASE IS EQ Number

Row = Row + 2

! Display a different message, depending on the number of guesses

SELECT CASE Counter

CASE 1

Print "Amazing!",@(0,Row)

CASE 2;3;4

Print "Excellent job!",@(0,Row)

CASE 5;6;7

Print "Congratulations!",@(0,Row)

CASE 8;9;10

Print "Not too bad.",@(0,Row)

CASE IS GT 10

Print "Your guessing skills need some work.",@(0,Row)

ENDSELECT

! Convert number and counter to strings, and strip the

! leading and trailing blanks (for display purposes)

Number$ = STRIP(STR(Number))

Counter$ = STRIP(STR(Counter))

! Display game-ending message

Row = Row + 1

Print "I was thinking of ",@(0,Row) ; Number$

Print " and you figured it out in " ; Counter$

! Check for singular or plural

IF Counter = 1 THEN

Print " guess."

ELSE

Print " guesses."

ENDIF

! Jump to the PlayAgain routine

GOTO PlayAgain

High: ! The guess is too high

CASE IS GT Number

Print Guess,@(50,Row) ; "is too high."

Low: ! The guess is too low

CASE IS LT Number

Print Guess,@(50,Row) ; "is too low."

ENDSELECT

KeepGoing: Row = Row + 1

Print "What is your next guess?" , @(0,Row)

NextGuess: Input @(30,Row),Guess

! Validate the input. If out of range, try again.

IF Guess LT 1 OR Guess GT 100 THEN

GOTO NextGuess

ENDIF

GOTO Evaluate

! - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

PlayAgain: ! Display prompt and input answer

Row = Row + 2

Print "Play again? (Y/N)" , @(0,Row)

Input @(18,Row),Answer$

! Convert the answer to upper case

Answer$ = UCASE(Answer$)

! If the answer is "Y" then go back to the top

IF Answer$ = "Y" THEN

GOTO Top

ELSE

STOP

ENDIF

END

??? Note: This program has been changed. It now contains sound effects.

SAMPLE4

This program displays a list of coin combinations (using nickels, dimes, and quarters) where the total value is exactly $1.00. The program evaluates all combinations, rejecting the ones that don't add up to $1.00.

This program demonstrates two additional IB features:

1. The FOR/NEXT loop counts how many times the loop is executed. (If fact, this program has nested FOR/NEXT loops, one for each denomination of coin.)

2. The (Screen) control code sets the size of the IB client window. While the default size is 80 columns by 25 rows, the value can be changed up to a maximum of 255 by 255. In this example, the screen is set to 80 x 40.

The source program is named SAMPLE4.MTB.

! //MTB// Src(SAMPLE4.MTB,BAS) Obj(SAMPLE4,BAS)

! Define the variables

LENGTH 1.0

LOCAL QUARTERS

LENGTH 2.0

LOCAL DIMES,NICKELS,ROW,COUNTER

LENGTH 3.2

LOCAL TOTAL

LENGTH 2

LOCAL COUNTER$

! Here's the code

Print (CS) ! Clear the screen

Print (Screen=80,40) ! Set screen size to 80 x 40

Print "The following combinations add up to exactly $1.00",@(0,0)

Print "Nickels",@(0,2);"Dimes",@(10,2);"Quarters",@(20,2)

ROW = 2 ! Set row value to 2

COUNTER = 0 ! Initialize the counter

FOR QUARTERS = 0 TO 4 ! Loop through quarters

FOR DIMES = 0 TO 10 ! Loop through dimes

FOR NICKELS = 0 TO 20 ! Loop through nickels

! Calculate the total value

TOTAL = NICKELS*.05 + DIMES*.1 + QUARTERS*.25

! If the total value equals $1.00, then display then

! number of coins and increment the counter

IF TOTAL = 1 THEN

ROW = ROW + 1

PRINT NICKELS,@(0,ROW);DIMES,@(10,ROW);QUARTERS,@(20,ROW)

COUNTER = COUNTER + 1

ENDIF

NEXT NICKELS

NEXT DIMES

NEXT QUARTERS

! Display summary message at the bottom of the screen

ROW = ROW + 2

COUNTER$ = STRIP(STR(COUNTER))

Print @(0,ROW);"There are ";COUNTER$;" combinations."

! Display ending message and use a "dummy INPUT" to hold it there

ROW = ROW + 2

Print @(0,ROW);"Press ENTER to continue..."

Input @(30,ROW),""

STOP

END

SAMPLE5

This program displays the first 26 numbers in the Fibonacci sequence, where each number is equal to the sum of its two predecessors. The initial values are 0 and 1.

This program also displays the ratio of each number and its immediate predecessor. When you run this program, notice that the ratio converges very quickly to a value of 1.61803. This value is well known in mathematics, nature, architecture and art, and is called the "Golden Mean."

The source code contains several additional IB features:

1. The looping in this program is controlled by a DO loop. In this example, the loop starts with the statement DO UNTIL C > 50000. The loop structure ends with the LOOP statement.

2. This program demonstrates an important point in the way IB handles the division operation. Here's the rule: "The result of a division operation is as precise as the most precise value in the formula."

The ratio in this program is calculated by dividing one integer by another. In order to calculate a value with 5 digits precision, the formula must contain an extra term with 5 digits of precision. Thus, the formula is 1.00000*C/B.

The source program is named SAMPLE5.MTB.

! //MTB// Src(SAMPLE5.MTB,BAS) Obj(SAMPLE5,BAS)

! Define the variables

LENGTH 2.0

LOCAL ROW

LENGTH 5.0

LOCAL A,B,C

LENGTH 6.5

LOCAL RATIO

! Here's the code

Print (CS) ! Clear the screen

Print (Screen=80,35) ! Set screen size to 80 x 35

Print "This program displays numbers in the Fibonacci sequence",@(0,0)

Print "and the ratio of each number and its preceding value.",@(0,1)

Print "Number",@(0,3);"Ratio (also known as the 'Golden Mean')",@(10,3)

A = 0 ! Set the initial values

B = 1

Print A,@(0,4) ! Print the initial values

Print B,@(0,5)

ROW = 5 ! Set the row counter

DO UNTIL C > 50000 ! Start loop & set upper limit

C = A + B ! Find the next Fibonacci number

RATIO = 1.00000*C/B ! Calculate the ratio C:B

!

! Note: This formula requires

! an extra term (1.00000) to

! force the precision of the

! result to 5 digits.

ROW = ROW + 1 ! Increment the row counter

Print C,@(0,ROW);RATIO,@(10,ROW) ! Display the value, ratio

A = B ! Exchange the values

B = C

LOOP ! Loop

! Display ending message and use a "dummy INPUT" to hold it there

ROW = ROW + 2

Print @(0,ROW);"Press ENTER to continue..."

Input @(30,ROW),""

STOP

END

SAMPLE6

This program shows what happens when you start with one cent and double it every day for a month.

This program contains features shown in earlier examples (screen resizing, FOR/NEXT loop, variable positioning, etc.), but contains one noteworthy feature – a very large numeric variable. The AMOUNT variable is defined with a length and precision of 16.2, meaning that the variable can hold up to 16 digits, two of which are to the right of the decimal point.

The source program is named SAMPLE6.MTB.

! //MTB// Src(SAMPLE6.MTB,BAS) Obj(SAMPLE6,BAS)

! Define the variables

LENGTH 2.0

LOCAL ROW

LENGTH 2.0

LOCAL I

LENGTH 16.2 ! That's a big number!!!

LOCAL AMOUNT

! Here's the code

Print (CS) ! Clear the screen

Print (Screen=80,40) ! Set screen size to 80 x 40

Print "If you start with 1 cent and double it every day,",@(0,0)

Print "how much money will you have within a month?",@(0,1)

Print "Day",@(0,3);"Amount",@(21,3)

AMOUNT = .01 ! Set the initial amount

ROW = 4 ! Set the row counter

FOR I = 1 TO 31 ! Loop from 1 to 31

Print I,@(0,ROW);AMOUNT,@(10,ROW) ! Print day #, amount

AMOUNT = AMOUNT * 2 ! Double the amount

ROW = ROW + 1 ! Increment row counter

NEXT I ! Loop

! Display ending message and use a "dummy INPUT" to hold it there

ROW = ROW + 1

Print @(0,ROW);"Press ENTER to continue..."

Input @(30,ROW),""

STOP

END

MENU1

The final program in this chapter is one that ties together the other examples. This is a menu program. Here's what you'll see when you run this program:

Choose one of the following programs

------------------------------------

1 -- Temperature conversion

2 -- Break even calculation

3 -- Number guessing game

4 -- Coin counting example

5 -- Fibonacci numbers and the 'Golden Mean'

6 -- What happens if you double your money every day?

Your choice: ___

This program shows how one IB program can run another. The source program contains a SELECT structure, where each valid option is evaluated and carried out with multiple CASE statements. The RUN statement executes the named program. For example, if the user enters a 1, the program executes the following statement:

RUN "SAMPLE1"

The same reasoning applies for the other options.

The source program is named MENU1.MTB. Here is the code:

! //MTB// Src(MENU1.MTB,BAS) Obj(MENU1,BAS)

! Define the variable

LENGTH 1 ! One byte

LOCAL Choice$ ! Local variable

! Here's the code

Top: Print (CS) ! Clear the screen

! Display the menu items

Print "Choose one of the following programs" , @(0,3)

Print "------------------------------------" , @(0,4)

Print "1 -- Temperature conversion" , @(0,6)

Print "2 -- Break even calculation" , @(0,8)

Print "3 -- Number guessing game" , @(0,10)

Print "4 -- Coin counting example" , @(0,12)

Print "5 -- Fibonacci numbers and the 'Golden Mean'",@(0,14)

Print "6 -- What happens if you double your money every day?",@(0,16)

Print "Your choice:" , @(0,18) ! Display prompt

Input @(13,18),Choice$ ! Input choice

SELECT CASE Choice$ ! Begin case structure

CASE "" ! If input is null,

STOP ! stop the program

CASE "1" ! If input is "1"

RUN "SAMPLE1" ! RUN "SAMPLE1"

CASE "2" ! If input is "2"

RUN "SAMPLE2" ! RUN "SAMPLE2"

CASE "3" ! If input is "3"

RUN "SAMPLE3" ! RUN "SAMPLE3"

CASE "4" ! If input is "4"

RUN "SAMPLE4" ! RUN "SAMPLE4"

CASE "5" ! If input is "5"

RUN "SAMPLE5" ! RUN "SAMPLE5"

CASE "6" ! If input is "6"

RUN "SAMPLE6" ! RUN "SAMPLE6"

CASE ELSE ! Otherwise

GOTO Top ! Go to statement label "Top"

ENDSELECT ! End of case structure

END

Notice the CASE ELSE statement towards the end of the SELECT CASE structure. This is an “otherwise” clause, so if the user enters something other than a valid option, the program branches back to the top of the code section and re-displays the menu.

Here’s how to connect all of the sample programs in this chapter. Edit the source code for SAMPLE1.MTB through SAMPLE6.MTB. Make the following replacement in all of these programs:

Original statement Change it to this statement

STOP RUN "MENU1”

Re-compile the six sample programs. Now run MENU1 and choose one of the six options. The six sample programs now end by running the MENU1 program, which links all of these programs together.

Summary

This chapter provided your first look at InternetBasic source code. While the examples are very simple, they demonstrate quite a few fundamentals of the IB language. Of course, there are more features, more rules, and more sample programs ahead. In the next chapter, we'll take a look at some of the IB rules.