Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ttinet.com/doc/language_v44_003.html below:

INTOUCH® 4GL A Guide to the INTOUCH Language

This chapter describes the basic elements that make up an INTOUCH program. It also describes the types of data used with INTOUCH programs and how the data is processed.

When you create a program, you must use instructions that INTOUCH understands. The INTOUCH language provides these instructions. The language consists of statements. These statements are something like the words in this manual. You put them together in a meaningful order and INTOUCH executes the program you write. Here is an example of an INTOUCH program:

        10  INPUT 'Please enter your name': name$ 
        20  PRINT 'Hello, '; name$ 
            PRINT 'Today is '; day$ 
            PRINT name$; ', have a good '; day$ 
        30  END 

The INPUT statement tells INTOUCH to ask for a name. The PRINT statements tell INTOUCH to print the information. END tells INTOUCH it has reached the end of the program.

With INTOUCH, when you execute this program, it will look like this:

INTOUCH
 
10  INPUT 'Please enter your name': name$ 
20  PRINT 'Hello, '; name$ 
    PRINT 'Today is '; day$ 
    PRINT name$; ', have a good '; day$ 
30  END 
 
INTOUCH
 
RUN 
NONAME         2-MAY-1996 10:45 
Please enter your name? Julian 
Hello, Julian 
Today is Tuesday 
Julian, have a good Tuesday 
 
INTOUCH

RUN is a command. RUN tells INTOUCH to perform the instructions you have given. You will need to use commands as well as statements to develop your programs.

When you run the above program, you will notice that the day is not asked for. DAY$ is a reserved word that INTOUCH uses to store the day in. There are several other reserved words that INTOUCH uses. You can refer to Appendix B, Reserved Words to see a list of the reserved words.

INTOUCH programs are modular in structure. Every program can be divided into program units. The main unit is the main body of the program. This unit begins with the first program line and ends with the END statement.

    First program line --   10  INPUT 'Please enter your name': name$ 
                            20  PRINT 'Hello, '; name$ 
                                PRINT 'Today is '; day$ 
                                PRINT name$; ', have a good '; day$ 
         END statement --   30  END 

Each program unit is made up of program lines. A program line consists of one or more statements. In the above example, line 20 has three statements. If you include more than one statement in a line, you must separate the statements with a line terminator (a carriage return). You can terminate a line from the keyboard by pressing the [Return] or [Enter] key. For example:

        10  INPUT 'Please enter your name': name$<Return> 
        20  PRINT 'Hello, '; name$<Return> 
            PRINT 'Today is '; day$<Enter> 
            PRINT name$; ', have a good '; day$<Return> 
        30  END<Return> 

When INTOUCH executes a program, it starts at the lowest line number and executes all the statements in that program line. Then it goes to the next sequential line number and executes all the statements in that line and so on.

Multiple statements can be placed on a single line, delimited by the \ (backslash). CHR$(10) also signals the same as a \. A \ terminating the line implies an "&".

        10  FOR z1 = 4. to 7. STEP .5 \ PRINT z1 \ NEXT z1 
        20  END 
 
        RNH 
         4 
         4.5 
         5 
         5.5 
         6 
         6.5 
         7 

INTOUCH accepts line numbers in the range of 1 to 999999. Line numbers must be integers.

INTOUCH allows programs with NO line numbers execpt, there must be a line 1 at the beginning of the program. For example:

        1  PROGRAM print_name 
                ------- 
                ------- 
                ------- 
           END 

You can continue a statement on the next physical line by using an ampersand (&). This allows you to continue a statement that is too long to fit on one line.

To continue a statement, place the ampersand at the end of the continued line. You can also place an optional ampersand at the beginning of the next line. For example:

        10  INPUT 'Please enter your name': name$ 
        20  PRINT 'Hello, '; name$ 
            PRINT 'Today is '; day$ 
            PRINT name$; & 
                  ', have a good '; &      ! required ampersand 
                  & day$                   ! optional ampersand 
        30  END 
 
        RNH 
        Please enter your name? Julian 
        Hello, Julian 
        Today is Tuesday 
        Julian, have a good Tuesday 

You can continue statements between words; however, you cannot break up a word.

• comma (,) list items
• all operators having two arguments; i.e. trailing "+", "AND", "OR", "*", "/", etc. implies that the rest of the code is on the following line

NOTE: Comma-separated list continuation does not work in a PRINT statement. PRINT statements still require the trailing "&" for continuation.

Here are some examples:

        10  OPEN STRUCTURE cust: NAME 'tti_run:customer',    ! no ampersand 
              ACCESS OUTIN,                                  ! no ampersand 
              LOCK 
        20  CLOSE STRUCTURE cust 
        30  END 
 
 
 
        10  PRINT 'Today is the first day of the ' +         ! no ampersand 
            'rest of your life.' 
        20  a$ = 'walk' 
            b$ = 'walk' 
            c$ = 'walk' 
        30  IF  a$ = b$  AND                                 ! no ampersand 
              a$ = c$  THEN 
              PRINT 'All are the same.' 
            END IF 
        40  END 
 
        RNH 
        Today is the first day of the rest of your life. 
        All are the same. 

A label is a way to identify a place in a program. Labels must:

• begin with a letter
• can be up to 31 characters long
• can contain letters, digits and underscores

To use a label, put the label name on a program line and separate it from the following statement with a colon. The label name can also be put on a line by itself and followed by multiple statements. Both options are shown in the example below.

        10  ask_input:  INPUT 'Please enter your name': name$ 
        20  do_print: 
            PRINT 'Hello, '; name$ 
            PRINT 'Today is '; day$ 
            PRINT name$; ', have a good '; day$ 
        30  END 

INTOUCH programs have a default extension of .INT so, you do not have to use a file extension with your file name when using the INTOUCH commands (SAVE, UNSAVE, OLD, etc.). It is recommended that you use this extension for all of your INTOUCH programs.

INTOUCH source programs are saved as text files. You can print the text files with the TYPE and PRINT commands, and edit them with any text editor.

1. integer numbers
2. real numbers
3. and string (textual) data

The following sections describe each of the three types of data.

Integers can be positive or negative. Integer constants can end with a trailing percent sign (%). About integers:

• Names for integer variables, arrays or functions must be designated by a trailing percent sign (%) or declared with a DECLARE statement.
• A negative integer constant is designated by a leading minus sign.
• A positive integer constant can be designated by a leading plus sign or by the absence of a sign.
• Integers have a size of 32 bits.
• INTOUCH allows integer numbers anywhere in the range of -2147483648 to +2147483647.

Real numbers can be positive or negative. Any number that is not designated as an integer or a string is treated as a real number.

A real number without a decimal point is called an ambiguous constant. About real numbers:

• A variable, array or function whose name has no trailing % or $ is treated as a real number unless it is declared.
• A negative real constant has a leading minus sign.
• A positive real constant can have a leading plus sign or no sign.
• Ambiguous constants are treated as real numbers with a fractional part of 0. (5 = 5.0)
• Real numbers have a size of 64 bits, a precision 15 decimal digits and correspond to the VAX double floating point number.
• Real numbers can be anywhere in the range of -1.7E38 to +1.7E38.
• Real numbers have a precision of .29E-38 to 1.7E38.

                 'Hello, Fred.' 
 
                 'Account number (##-####)' 
 
                 '65' 

About string data:

• String constants must be enclosed in single or double matching quotes. String variables must be designated by a trailing dollar sign ($) or declared with a DECLARE statement.
• A string can contain up to 65535 characters.
• String variables are dynamic in length.

        10  done? = FALSE 
            DO 
              INPUT 'Ready': ans$ 
              IF  _EXIT  THEN  done? = TRUE 
              IF  _BACK  THEN  done? = TRUE 
            LOOP UNTIL done? 
        20  END 

Expressions can be:

• constants
• simple variables
• array elements. Array elements are a type of variable.
• structure references. Structure references are a feature of the INTOUCH data structure system.
• substrings.
• compound expressions. Compound expressions are any combination of the above operands separated by operators.

Real numeric constants are written with a sign, digits, and a decimal point. For example, 5.38 is a real numeric constant.

If you wanted to represent 1000 in E notation, you would use:

This means "take 1 and multiply it by 10 to the 3rd power" which is 1*(10^3) = 1000. If you wanted to represent .01, you would use a negative exponent.

String constants must be enclosed in quotes. The quotes are called string delimiters. They tell INTOUCH where the string begins and ends. The quotes are not considered part of the string. Everything within the quotes is considered part of the string. Note that the following strings are different:

        10  PRINT 'Account number (##-####)' 
        20  PRINT '    Account number     (##-####)' 
        30  END 
 
        RNH 
        Account number (##-####) 
            Account number     (##-####) 

An empty string is called a null string. A null string is indicated by a pair of quotes with nothing between them ("").

String delimiters can be single quotes (') or double quotes ("). However, the quotes must match and be paired.

Quotes can be included as part of a string by using them within the string delimiters. For example:

        "Message 'Time to go home!'" 

The string part of this is:

         Message 'Time to go home!' 

The delimiter quotes can be used within a string, by repeating them twice. For instance:

        "Message ""Time to go home!""" 

The string part of this is

         Message "Time to go home!" 

Variables are a way of storing values that can change in the program during execution. A variable names a storage location. The value of the variable is stored in this location. Here are two types of variables:

• Simple variables such as: AVERAGE and NAME$
• Array elements such as: AVERAGE(3) and NAME$(2,12)

Two other constructs are used in ways similar to variables---you can use them in expressions and assign values to them:

• Substrings such as: NAME$[7:12]
• Structure references such as: SALES(AVERAGE) and CLIENT(PHONE)

Variables are represented by a name consisting of a letter or a series of letters, numbers and underscore characters. Variables:

• must start with a letter.
• can be followed by a proper data type designation (% for integers and $ for strings).
• can be declared explicitly.

Some examples of valid variables are:

Variables can be integer numeric, real numeric or string. Integer variables can only contain integer values. If a real numeric value is assigned to an integer variable, INTOUCH rounds the real number and uses the resulting integer.

String variable names can have a trailing dollar sign ($). If numeric data is assigned to a string variable, an exception occurs.

                TODAY$           X$ 
                LAST_NAME$       ANSWER$ 

A variable that is not followed by a $ or a % is treated as a real numeric variable unless it is declared. If you assign string data to a real numeric variable, an error will result. If you assign integer data to a real numeric variable, INTOUCH treats it as a real number with a fractional part of 0. The following are examples of real numeric variables:

INTOUCH uses the last assigned value when a variable is referenced.

                QUANTITY(1) 
                QUANTITY(2) 
                QUANTITY(3) 
                QUANTITY(4) 
                QUANTITY(5) 

To indicate which element you want to access, you use numbers after the array name called subscripts. The subscripts are enclosed in parentheses. Example: AMOUNT(3,2)

Subscripts must be given as integers. If a real numeric subscript is given, it will be rounded and the integer portion used. Arrays can contain real numeric, integer or string values. String and integer arrays are designated by placing the appropriate symbols after the array name and before the subscript. For example:

About arrays:

• Arrays must be defined with the DIM statement and can be redefined with the REDIM statement.
• Arrays can have up to 32 dimensions.
• An array can have as many elements as memory allows.
• Integer and string arrays must be designated by the appropriate symbol (% for integers, $ for strings) or else they must be declared.
• Subscripts must be integers. Real subscripts are rounded.
• Multiple subscripts must be separated by commas.
• The default low bound for an array is 1 or the number indicated with the OPTION BASE statement. (See Section 10.1.3)
• You can indicate the low bound explicitly with a TO clause:
  DIM COSTS(5 TO 10)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4