Omikron BASIC for Apple Power Mac

4. Basics Contents | 5-2. ABS - CINT

 

Chapter 5-1

The Command Set

& to @



&
Type: Operator
Syntax: &{<variable|<function>}
Explanation: The address operator determines the address of a variable, of a field, or of a function.

The following is indicated here:
- in the case of numerical single variables, the value of the variable
- in the case of individual string variables, a 4-byte pointer to the actual string, followed by a 4-byte string length
- in the case of numerical fields, a pointer to the actual field
- in the case of string fields, a pointer to a field containing the pointer to the elements of the string field and their length
- in the case of functions, a pointer to the function

In order to access the variable, it is possible to also employ the "*" dereferencing operator.
The address operator in particular can be utilized in order to pass pointers to fields or functions to procedures and functions respectively. Consequently, fields can be processed locally and functions can be called indirectly.


"*" accesses an object (dereferences it). The pointer variable must follow directly behind the operator. Just as in the case of a normal variable, the proposed type has to be indicated with a postfix. "*" calls the function to which the pointer variable points, especially in case of a pointer to functions.

Note: The address operator is very important for direct MAC_OS calls, because for many of these functions, pointers do have to be passed to variables in which MacOS then returns the results. Extreme care has to be taken to indicate the correct type; an automatic adaptation such as it occurs in the case of Omikron Basic is not performed by the MacOS.
Example: Text$="This is a sample text"
Ptr_Text=&Text$
PRINT *Ptr_Text$:'The $ character is important!
Sum=0
Ptr_Sum=&Sum
N=10
FOR I= 1 TO N
 *Ptr_Sum=*Ptr_Sum+I*I
NEXT I
PRINT Sum
Result: This is a sample text
385
See also: VARPTR * (as pointer operator)
   

(,)
Type: Operator
Syntax: (<expression>)
Explanation: An expression placed within parentheses always has the highest priority and is computed ahead of any other expression. Expressions in parentheses can be nested as desired. It is also possible to interpret the parenthesis as a function, which returns the result of <expression> as the function value.
Example: PRINT 3*5+7
PRINT 3*(5+7)
Result: 22
36
See also: Priority of the Operators
   

* (as pointer operator)
Type: Operator
Syntax: *{<variable>|<function>}
Explanation: In order to be able to use the pointer operator, it is first necessary to determine the address of an object (variable, field, or function) by using the address operator "&". The expression 'Ptr_Str_Cmp=&FN Cmp(A$, B$)' saves a pointer to the function 'FN Cmp(,)' in the variable 'Ptr_Str_Cmp' - meaning their addresses. The function can now be called indirectly with this pointer (e.g., 'PRINT FN *Ptr_Str_Cmp("A","B")').

Just as pointers to a field, such function pointers can be passed to procedures. It would be possible to use a sort procedure with the above-mentioned example, which only receives a function pointer for the string comparison. The sorting criteria are contingent on the logical operator (e.g., ascending, descending, or upper case = lower case ...)

Important: Close attention has to be paid to ensure that the parameter lists of the functions that can be called via pointers are in precise agreement. The compiled product cannot carry out any type adaptation at runtime since it is not known to which function the pointer is referring at any point in time. In the above example, FN *Ptr_To_Df_Fn may only be called with a double float parameter (here X#). The otherwise necessary conversion of integer to double float cannot occur automatically, the integer parameter would pass incorrectly.
Example: 'This example can also be found in the DEMO folder
Ptr=&FN Sin2#(X#)
PRINT "Value Table of Sine-Squared:" :PRINT
Values_Tab Ptr,0#,PI,0.2#

SCREEN 1,80,80,320,400
PRINT "Value Table of Cosine-Squared:":PRINT
Values_Tab &FN Cos2#(X#),0#,PI,0.2#
REPEAT COMPILER "EVENT" UNTIL 0
END

DEF FN Sin2#(X#)= SIN(X#)* SIN(X#)
DEF FN Cos2#(X#)= COS(X#)* COS(X#)
DEF PROC Values_Tab(Ptr_To_Df_Fn,From#,To#,Step#)
 LOCAL X#
 For X#=From# TO To# STEP Step#
  PRINT USING "##.#;X#; USING "";TAB(5);FN *Ptr_To_Df_Fn#(X#)
  'Caution: While the program is running, it is impossible to check the type
 NEXT X#
END_PROC
Result: Two windows will be opened and the squares of sine and cosine displayed in each case.
See also: &     VARPTR 
   

* (as a multiplication operator)
Type: Operator
Syntax: {<num.expression>|<string expression>}*<num.expression>
Explanation: The multiplication operator multiplies the expression indicated to its left with the numerical expression indicated to its right. Instead of the numerical expression, a string expression can also be employed on the left side.
Example: PRINT 5*7
PRINT "Basic"*3
Result: 35
BasicBasicBasic
See also: /     \     STRING$     SPACE$     SPC    MAT   *(as pointer operator) 
   



+ (as sign)
Type: Operator
Syntax: + <num.expression>
Explanation: The positive sign operator indicates that this numerical expression is a positive number. The "+" operator acts as a multiplication by 1, thus not changing the value of the number. In general, it can be omitted. Omikron Basic employs a blank space instead of the "+" character during the output of numbers. However, this behavior can be changed with USING.
See also: + - (as signs)
   


+
Type: Operator
Syntax: {<num.expression> + <num.expression > | <string expression > + <string expression >}
Explanation: The addition operator adds the expression on its left to the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permissible.
Example: PRINT 100+21
PRINT "Omikron"+"Basic "+" Version 6"
Result: 121
Omikron Basic Version 6
See also: -      +  (as sign)   MAT
   

- (as sign)
Type: Operator
Syntax: - <num.expression>
Explanation: The negative sign operator indicates that this numerical expression is a negative number. The "-" operator acts as a multiplication by -1, thus negating the value of the number. The operator is inverse to itself. Therefore, a double application thus produces again the initial number.
Example: A=1234
PRINT -A,-(-A+1)
Result: -1234 1233
See also: -      +  (as sign)
   


-
Type: Operator
Syntax: <num.expression> - <num.expression >
Explanation: The subtraction operator subtracts the expression on its right from the expression on its left. However, only numerical expressions are permitted but no string expressions.
See also:      -   (as signs)   MAT 
   

/
Type: Operator
Syntax: <num.expression> / <num.expression>
Explanation: The division operator divides the expression on its left by the expression on its right. However, only numerical expressions are permitted and no string expressions.
See also: \     *      MAT 
   


\
Type: Operator
Syntax: <num.expression> / <num.expression>
Explanation: The integral division operator divides the expression on its left by the expression on its right. However, only numerical expressions are permitted, no string expressions. In contrast to the normal division operator, the returned result is always an integer. If therefore, the division cannot divide exactly, the result is rounded down to the next smaller integer.
Example: PRINT 10/4,10\4
Result: 2.5 2
See also: /     *         MOD 
   


^
Type: Operator
Syntax: <num.expression> ^ <num.expression>
Explanation: The power operator raises the expression on its left to the power indicated by the expression on its right. However, only numerical expressions are permitted, no string expressions.

Note: Calculation occurs through a series expansion. Therefore, this operation is very slow compared to the basic arithmetic operations. If the operation can also be written as a basic arithmetic operation, it is better to use it instead (e.g., X*X is executed much faster than X^2, 1/X is better than X^-1, SQR(X) is more rapid than X^0.5)
See also: LOG   LN   SQR    
   

<
Type: Operator
Syntax: {<num.expression> < <num.expression> | <string expression> < <string expression>}
Explanation: The 'less than' operator compares the expression on its left with the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permitted. The result is a Boolean value. If the expression on the left side of the operator is less than the expression on the right side of the operator, the returned result amounts to -1, otherwise 0.
In the case of strings, the logical comparison is performed character by character in terms of the respective ASCII value of the sign. Thus, "a" is less than "b". The strings may also differ in lengths.

Note: Such logical comparisons are generally used to control the program with such structure commands as IF, WHILE, UNTIL.
See also: <=   =       >=   >    <> 
   

<=
Type: Operator
Syntax: {<num.expression> <= <num.expression > | <string expression > <= < string expression >}
Explanation: The 'less than or equal to' operator compares the expression on its left with the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permissible. The result is a Boolean value. If the expression on the left side of the operator is lesser than or equal to the expression on the right side of the operator, the returned result amounts to -1, otherwise 0.
In the case of strings, the comparison is performed character by character in terms of the respective ASCII value of the sign. Thus, "a" is less than or equal to "b". The strings may also differ in lengths.

Note: Such logical comparisons are generally used to control the program with such structure commands as IF, WHILE, UNTIL.
See also: <    =    >=    >      <> 
   


=
Type: Operator
Syntax: {<num.expression> = <num.expression > | <string expression > = <string expression >}
Explanation: The logical comparison (equal to) operator compares the expression on its left with the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permissible. The result is a Boolean value. If the expression on the left side of the operator is equal to the expression on the right side of the operator, the returned result amounts to -1, otherwise 0.
In the case of strings, the comparison is performed character by character in terms of the respective ASCII value of the sign. Thus, "a" is equal to "b". The strings may also differ in lengths. In that case, however, the result is always 0.

Note: Such logical comparisons are generally used to control the program with such structure commands as IF, WHILE, UNTIL.
See also: <     <=     >=    >     <> 
   

>=
Type: Operator
Syntax: {<num.expression> >= <num.expression > | <string expression > >= <string expression >}
Explanation: The 'greater than or equal to' operator compares the expression on its left with the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permissible. The result is a Boolean value. If the expression on the left side of the operator is greater than or equal to the expression on the right side of the operator, the returned result amounts to -1, otherwise 0.
In the case of strings, the comparison is performed character by character in terms of the respective ASCII value of the sign. Thus, "b" is greater than or equal to "a".

Note: Such logical comparisons are generally used to control the program with such structure commands as IF, WHILE, UNTIL.
See also: <     <=    =    >     <>
   

>
Type: Operator
Syntax: {<num.expression>> <num.expression > | <string expression >> <string expression >}
Explanation: The 'greater than' operator compares the expression on its left with the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permissible. The result is a Boolean value. If the expression on the left side of the operator is greater than the expression on the right side of the operator, the returned result amounts to -1, otherwise 0.
In the case of strings, the comparison is performed character by character in terms of the respective ASCII value of the sign. Thus, "b" is greater than "a."

Note: Such logical comparisons are generally used to control the program with such structure commands as IF, WHILE, UNTIL.
See also: <     <=    =    >=    <> 
   

<>
Type: Operator
Syntax: {<num.expression> <> <num.expression > | <string expression > <> <string expression >}
Explanation: The 'not equal to' operator compares the expression on its left with the expression on its right. Instead of numerical expressions, string expressions can also be used; however, a combination of both is not permissible. The result is a Boolean value. If the expression on the left side of the operator is not equal to the expression on the right side of the operator, the returned result amounts to -1, otherwise 0.
In the case of strings, the comparison is performed character by character in terms of the respective ASCII value of the sign. Thus, "a" is not equal to "b". The strings may also differ in lengths. In that case, the result is always 0.

Note: Such logical comparisons are generally used to control the program with such structure commands as IF, WHILE, UNTIL.
See also: <     <=    =    >=    
   

= (as allocation)
Type: Command
Syntax: {<num.variable> = <num.expression>|<string variable> = <string expression>}
Explanation: The allocation operator assigns the expression on its right to the variable on its left. Only a numerical expression can be assigned to numerical variables, and only a string expression can be assigned to string variables. A combination of both is inadmissible.
See also: LET
   


+=
Type: Operator
Syntax: <num.variable> += <num.expression>
Explanation: This operator adds a numerical expression to a numerical variable and then immediately reassigns the result to the variable. Therefore, A+=B is tantamount to A=A+B; however, it can be translated more effectively by the compiler. It is advisable, to make use of this style as often as possible.

Note: The Omikron Basic compiler always attempts to translate an expression such as the format A=A+B as A+=B. Nevertheless, use of the operator "+=" is advised.
See also: -=     *=     /= 
   


-=
Type: Operator
Syntax: <num.variable> -= <num.expression>
Explanation: This operator subtracts a numerical expression from a numerical variable and then immediately reassigns the result to the variable. Therefore, A-=B is tantamount to A=A-B; however, it can be translated more effectively by the compiler. It is advisable, to make use of this style as often as possible.

Note: The Omikron Basic compiler always attempts to translate an expression such as the format A=A-B as A-=B. Nevertheless, use of the operator "-=" is advised.
See also: +=     *=     /= 
   


*=
Type: Operator
Syntax: <num.variable> *= <num.expression>
Explanation: This operator multiplies a numerical expression with a numerical variable and then immediately reassigns the result to the variable. Therefore, A*=B is tantamount to A=A*B; however, it can be translated more effectively by the compiler. It is advisable, to make use of this style as often as possible.

Note: The Omikron Basic compiler always attempts to translate an expression such as the format A=A*B as A*=B. Nevertheless, use of the operator "*=" is advised.
See also: +=     -=     /= 
   

/=
Type: Operator
Syntax: <num.variable> /= <num.expression>
Explanation: This operator divides a numerical variable by a numerical expression and then immediately reassigns the result to the variable. Therefore, A/=B is tantamount to A=A/B; however, it can be translated more effectively by the compiler. It is advisable, to make use of this style as often as possible.

Note: The Omikron Basic compiler always attempts to translate an expression such as the format A=A/B as A/=B. Nevertheless, use of the operator "/=" is advised.
See also: +=    -=    *= 
   

{...}
Type: Command
Syntax: {<program text>}
Explanation: An area enclosed in braces { } within the source code can be summarized as one single line using the editor function 'Fold Area'. The command does not influence the program execution and is ignored by the compiler.
See also: Fold Area   Unfold Area   Unfold All 
   

?
Type: command
Syntax: ? [[<expression>][,[[<expression>]<,|;>]...]
Each word 'expression' can be replaced by:
{TAB(<num.expression>) | USING [<string expression>] | <num.expression> | <string expression>}
Explanation: The question mark has the same definition as the PRINT command. The editor will immediately convert it into PRINT after exiting the line.
See also: PRINT
   


' (comment)
Type: Command
Syntax: '<string constant>
Explanation: A comment is introduced with the single quotation mark. Anything following the single quotation mark will be ignored by the compiler. Ample use should be made by the opportunity to add comments to the program. This makes it easier to still understand the program execution even after the user has not worked with the program for a longer period of time.
See also: REM
   

@
Type: Function
Syntax: @(<num.expression>,<num.expression)
@(<line>,<column>)
Explanation: This function returns a control string. If this string is output with commands such as e.g., PRINT, LPRINT, or INPUT, the cursor will be placed in the line and column specified behind "@".
In the case of LPRINT, certain restrictions may apply, because it is obvious that the cursor cannot be placed in a location that has already been printed out.
See also: PRINT @
   
 


4. Basics Contents | 5-2. ABS - CINT

Tech-Support | Order | Start | Home: http://www.berkhan.com


© 1997-2001 Berkhan-Software