Else

ElseIfPlatform

EndApp

Identify, for the compiler, an application that is no longer used in a macro (see Application).

EndApp is a non-executable statement that can occur anywhere in a macro. After EndApp, a product command to the application specified by EndApp creates a compile-time syntax error.

EndFor

EndFunc

EndFunction

EndIf

EndIfPlatform

Close an IfPlatform conditional compile statement. See IfPlatform.

The parameter is optional and ignored. Its only purpose is to document what it goes with.

EndProc

EndProcedure

EndPrompt

EndSwitch

EndWhile

EndWith

EnvVariableGet

EnvVariableSet

Error

ErrorNumber

Notes

ErrorNumber is a macro system variable that returns an enumeration, which can be referred to by name. The enumerations have the same numeric values as in previous versions. The value of ErrorNumber is cleared before every command. After the command is excuted, ErrorNumber returns a value that indicates if an error occured. If a handler condition is disabled, the macro continues when the specified condition occurs. You can test ErrorNumber manually for ErrorNumber.Success!. Commands that do not reset Error

Number are MacroInfo(ErrorNumber!) calls, ErrorNumber itself, and compound statements, such as If- Endif, Switch-EndSwitch, Repeat-Until, While- EndWhile, For-EndFor, and so on. Copy the value returned by ErrorNumber into a variable if the value is needed after executing other macro commands, such as PROMPT, which reset ErrorNumber.

Exists

Determine if a variable exists.

To exist, a variable must be declared and initialized. Given that variable w is declared and not initialized, and that Local x is initialized to 5, Global y to 10, and Persist z to 15, the following statements are valid:

vNoInit := Exists(w)

Result: vNoInit equals Exists.NotFound!

vLocal := Exists(x)

Result: vLocal equals Exists.Local!

vGlobal := Exists(y)

Result: vGlobal equals Exists.Global!

vPersist := Exists(z)

Result: vPersist = Exists.Persistent!

If(Exists(vLocal))

Beep

EndIf

Explanation: Computer beeps because Exists returns a value other than Exists.NotFound!.

If(Exists(vLocal) = Exists.Persistent!)

Beep

EndIf

ExitHandlerState

Determine how a macro responds to an Exit condition.

Create an Exit condition with Assert(ExitCondition!).

Unlike Error, Cancel, and NotFound, ExitHandlerState does not prevent or enable a condition from occurring. It enables or disables calling the exit handler when an exit condition occurs.

ExponentPart

Return the exponent portion of a numeric value.

For example, the exponent of 3.2e18 is 18.

Factorial

False

The constant boolean value FALSE.

Fibonacci

FileConvert

Converts a file of one type to a file of another type. The available file types depends on the converters installed by the user. Not all conversions are available on all systems.

A file can only be converted to a similar file type (documents to documents, graphics to graphics, and so on).

FileConvertError

FileError

FileFind

A filename, or an empty filename if no match is found.

FileIsEOF

Return True if the insertion point is at the end of a file, False if not.

The access mode must be Read! (see OpenFile).

FileNameDialog

FilePosition

Return the current marker position or set a new position.

A user can pre-allocate file size by setting the position marker past the end-of-file marker.

FileRead

FileSize

The file size in bytes, or a negative number if an error occurs.

FileTruncate

FileType

FileTypeExtension

FileTypeList

FileTypeName

FileWrite

Floor

For

A control statement (loop) that executes a specified number of times (see Loop Statements in Chapter 5: Conditional, Loop, and Calling Statements).

The loop executes only if TerminateExp is true, and continues to execute until ControlVariable's value makes TerminateExp false. EndFor closes a For statement.

The general form of a For statement is:

For (<ControlVariable>; <InitialValue>;<TerminateExp>; <IncrementExp>)
 ...statement block...
EndFor

For example, the following statement initializes vTest to one, repeats the statement block while vTest is less than ten, and increments vTest by two after each loop.

For(vTest; 1; vTest 10; vTest + 2)
 ...statement block...
EndFor

ForEach

A loop statement that executes a number of times equal to the number of specified expressions (see Loop Statements in Chapter 5: Conditional, Loop, and Calling Statements).

ControlVariable is assigned the first value before the first loop; the second value before the second loop; the third value before the third loop; and so forth. The statement block uses the value of ControlVariable to direct macro execution. EndFor closes a ForEach statement.

The general form of a ForEach statement is:

ForEach (ControlVariable; {ValueList; ...})
 ...statement block...
EndFor

For example, the following statement repeats three times. The variable vTest is initialized to "Apples" before the first loop, to "Oranges" before the second, and to "Bananas" before the third.

ForEach(vTest; {"Apples"; "Oranges"; "Bananas"})
 ... statement block ...
EndFor

ForNext

A loop statement that executes a specified number of times (seeLoop Statements in Chapter 5: Conditional, Loop, and Calling Statements).

The loop executes if ControlVariable is less than or equal to FinalValue, and executes until ControlVariable is greater than FinalValue. If you use a negative value in IncrementValue, the loop executes until ControlVariable is less than FinalValue. EndFor closes a ForNext statement.

The general form of a ForNext statement is,

ForNext (ForNext (<ControlVariable>; <InitialValue>; <FinalValue>; <IncrementValue>)
 ...statement block...
EndFor

The following statement initializes vTest to one, repeats the statement block while vTest is less than or equal to five, and increments vTest by two after each loop.

ForNext(vTest; 1; 5; 2)
 ...statement block...
EndFor

Fraction

A fraction.

vFraction := Fraction(1.5)

Result: vFraction equals 0.5

vResult := Fraction(1.77 * 2)

Result: vResult = 0.54

FractionalPart

Return the fractional portion of a numeric value.

vFrac := FractionalPart (3.2)

Result: vFrac = 0.2

FractionStr

Return a fraction string representing a value.

vStr := FractionStr (4.5; 0; MixedFraction!)

Result: vStr = "4 1/2"

vStr := FractionStr (4.5; 8; MixedFraction!)

Result: vStr = "4 4/8"

Function

Identify a macro subroutine that can receive one or more values from a calling statement (see Calling Statements in Chapter 5: Conditional, Loop, and Calling Statements). Function also returns a value to the calling statement (caller).

Functions contain one or more statements that execute when the function is called. Unlike Label statements, functions do not execute unless called. A calling statement consists of the function's name, and can have one or more parameters that pass values to the function. Return, EndFunc, or EndFunction direct macro execution to the statement that follows the function's caller. Return also returns the result of a function operation, or 0 if no result is specified. For example,

y := 5
x := Add(y) // calling statement

Function Add(z)
 z := z + 5
 Return(z)
EndFunc

assigns the value 10 to variable x. Add is the name of the function, and y contains a value to pass. Variable z has no value until the function is called, when the value of z is function statement assigns 10 to variable z. The next statement returns the value of z to the calling statement, which is then assigned to variable x. If the function did not contain a Return statement, or if Return did not return a value, x would be equal to 0.

Address Mode

In the above example, the value of y does not change. The function returns the value of z in variable x. To change the value of a variable passed to a function, precede the calling statement parameter and its corresponding function parameter with an ampersand (&). For example,

y := 5
x := Add(&y)

Function Add(&z)
 z = z + 5
 Return(z)
EndFunc

assigns the value 10 to both x and y. The ampersand before variable x means the variable's address (location in memory) is passed to the function, not the variable's value. Changes made at the address of x are made to the contents of x.

Arrays

You pass arrays to functions the same way you pass variables. If you are passing the entire array, every array element must be assigned a value. If not, a run-time error identifies a reference to the undefined element. For example,

Declare w[10]
ForNext(x; 1; 9; 1) // assign only 9 elements
 w[x] = x
EndFor

Function Test(z[ ])
 ForNext(x; 1; 10; 1)
  x[z] = x * 10
 EndFor
 Return(z[ ]) // the value of 10 elements returned
EndFunc

y[ ] = Test(w[ ]) // 10 elements returned in array y[ ]
Type(y[10]) // y[10] equals 100
Type(w[10]) // Run-time error: Undefined variable "W[10]"

Function Test(&z[ ])

and

y[ ] = Test(&w[ ])

Pass the value of an array element, the same way you pass a variable. For example,

Declare w[10]
ForNext(x; 1; 10; 1)
 w[x] = x
EndFor

Function Test(z)
 z := z * 10
 Return(z)
EndFunc

y = Test(w[1])
Type(y + " - ")
Type(w[1])

The value of y equals 10. The value of w[1] equals 1. If you precede the calling statement parameter and the corresponding function parameter with an ampersand (&), the value of y equals 10 and the value of w[1] equals 10. Passing the address of w[1] causes its value to change inside the function. The two statements look like this:

Function Test(&z)

and

y = Test(&w[1])

The general form of a Function statement is:

Function <Name> (<Parameter>; <Parameter>; ... <Parameter>)
 ...statement block...
EndFunc

The syntax accepts EndFunc or EndFunction.