[<<Previous Entry] [^^Up^^] [Next Entry>>] [Menu] [About The Guide]
 STATIC
 Declare and initialize static variables and arrays
------------------------------------------------------------------------------
 Syntax

     STATIC <identifier> [[:= <initializer>], ... ]

 Arguments

     <identifier> is the name of the variable or array to declare static.
     If the <identifier> is followed by square brackets ([ ]), it is created
     as an array.  If the <identifier> is an array, the syntax for specifying
     the number of elements for each dimension can be array[<nElements>,
     <nElements2>,...] or array[<nElements>] [<nElements2>]...  The maximum
     number of elements is 4096.  The maximum number of dimensions is limited
     only by available memory.

     <initializer> is the optional assignment of a value to a new static
     variable.  An <initializer> for a static variable consists of the inline
     assignment operator (:=) followed by a compile-time constant expression
     consisting entirely of constants and operators or a literal array.  If
     no explicit <initializer> is specified, the variable is given an initial
     value of NIL.  In the case of an array, each element is NIL.  Array
     identifiers cannot be given values with an <initializer>.

     Note:  The macro operator (&) cannot be used in a STATIC declaration
     statement.

 Description

     The STATIC statement declares variables and arrays that have a lifetime
     of the entire program but are only visible within the entity that
     creates them.  Static variables are visible only within a procedure or
     user-defined function if declared after a PROCEDURE or FUNCTION
     statement.  Static variables are visible to all procedures and functions
     in a program (.prg) file (i.e., have filewide scope) if they are
     declared before the first procedure or user-defined function definition
     in the file.  Use the /N compiler option to compile a program with
     filewide variable scoping.

     All static variables in a program are created when the program is first
     invoked, and all values specified in a static <initializer> are assigned
     to the variable before the beginning of program execution.

     Declarations of static variables within a procedure or user-defined
     function must occur before any executable statement including PRIVATE,
     PUBLIC, and PARAMETERS.  If a variable of the same name is declared
     FIELD, LOCAL, or MEMVAR within the body of a procedure or user-defined
     function, a compiler error occurs and no object (.OBJ) file is
     generated.

     The maximum number of static variables in a program is limited only by
     available memory.

 Notes

     .  Inspecting static variables within the Debugger: To access
        static variable names within the CA-Clipper debugger, you must
        compile program (.prg) files using the /B option so that static
        variable information is included in the object (.OBJ) file.

     .  Macro expressions: You may not refer to static variables
        within macro expressions or variables.  If a static variable is
        referred to within a macro expression or variable, a private or
        public variable of the same name will be accessed instead.  If no
        such variable exists, a runtime error will be generated.

     .  Memory files: Static variables cannot be SAVED to or RESTOREd
        from memory (.mem) files.

     .  Type of a static local variable: Since TYPE() uses the macro
        operator (&) to evaluate its argument, you cannot use TYPE() to
        determine the type of a local or static variable or an expression
        containing a local or static variable reference.  The VALTYPE()
        function provides this facility by evaluating the function argument
        and returning the data type of its return value.

 Examples

     .  This example declares static variables both with and without
        initializers:

        STATIC aArray1[20, 10], aArray2[20][10]
        STATIC cVar, cVar2
        STATIC cString := "my string", var
        STATIC aArray := {1, 2, 3}

     .  This example manipulates a static variable within a user-
        defined function.  In this example, a count variable increments
        itself each time the function is called:

        FUNCTION MyCounter( nNewValue )
           STATIC nCounter := 0         // Initial value assigned once
           IF nNewValue != NIL
              nCounter:= nNewValue      // New value for nCounter
           ELSE
              nCounter++                // Increment nCounter
           ENDIF
           RETURN nCounter

     .  This example demonstrates a static variable declaration that
        has filewide scope.  In this code fragment, aArray is visible to both
        procedures that follow the declaration:

        STATIC aArray := {1, 2, 3, 4}

        FUNCTION One
           ? aArray[1]                  // Result: 1
           RETURN NIL

        FUNCTION Two
           ? aArray[3]                  // Result: 3
           RETURN NIL


See Also: FUNCTION LOCAL PARAMETERS PRIVATE PROCEDURE PUBLIC
This page created by ng2html v1.05, the Norton guide to HTML conversion utility. Written by Dave Pearson