{ } Preprocessor name reference

References the value of a preprocessor name in any ABL or preprocessor expression.

Syntax

{ &preprocessor-name }

Enter the braces ({}) as shown; they do not represent syntax notation in this description.

&preprocessor-name

Expands the name, preprocessor-name, to its defined value. You can define preprocessor names using either the &GLOBAL-DEFINE preprocessor directive or the &SCOPED-DEFINE preprocessor directive. ABL also provides a set of built-in preprocessor names that you can reference for a variety of session information. The following table lists each built-in preprocessor name with its description.

Built-in preprocessor names

The preprocessor name . . .	Expands to an unquoted string . . .
BATCH-MODE	Equal to "yes" if the Batch (-b) startup parameter was used to start the client session. Otherwise, it expands to "no".
FILE-NAME	That contains the name of the file being compiled.1 If you want only the name of the file as specified in the { } Include File Reference, the RUN statement, or the COMPILE statement, use the argument reference {0}.
LINE-NUMBER	That contains the current line number in the file being compiled. If you place this reference in an include file, the line number is calculated from the beginning of the include file.
OPSYS	That contains the name of the operating system on which the file is being compiled. The OPSYS name can have the same values as the OPSYS function. The possible values are "UNIX" and "WIN32".2
PROCESS-​ARCHITECTURE	That contains the bit value of the AVM process on which the file is compiled. The possible values include "32" and "64".3
SEQUENCE	Representing a unique integer value that is sequentially generated each time the SEQUENCE preprocessor name is referenced. When a compilation begins, the value of {&SEQUENCE} is 0; each time {&SEQUENCE} is referenced, the value increases by 1. To store the value of a reference to SEQUENCE, you must define another preprocessor name as {&SEQUENCE} at the point in your code you want the value retained.
WINDOW-SYSTEM	That contains the name of the windowing system in which the file is being compiled. The possible values include "MS-WINDOWS", "MS-WIN95", "MS-WINXP", and "TTY".4

Example

This procedure displays a message indicating whether the AVM is running on 32- or 64-bit Windows. This example is not valid if compiled in a 32-bit AVM and run in a 64-bit AVM, and vice versa.

DEFINE VARIABLE hProcess AS INTEGER NO-UNDO.
DEFINE VARIABLE Wow64Process AS INTEGER NO-UNDO.
DEFINE VARIABLE resultValue AS INTEGER NO-UNDO.

 &IF {&PROCESS-ARCHITECTURE} = 64 &THEN
  /* 64-bit processes always run on 64-bit Windows */
  MESSAGE "64-bit process running on 64-bit Windows".
&ELSE
  /* If a 32-bit process is running under WOW64 it must be
  ** running on 64-bit Windows. Otherwise, it is running on
  ** 32-bit Windows.
  */
  RUN GetCurrentProcess(OUTPUT hProcess).
  RUN IsWow64Process(hProcess, INPUT-OUTPUT Wow64Process, OUTPUT resultValue).

   MESSAGE "32-bit process running on " + (IF Wow64Process > 0 THEN "64" ELSE "32") + "-bit Windows".
&ENDIF

 PROCEDURE GetCurrentProcess EXTERNAL "kernel32.dll":
  DEFINE RETURN PARAMETER hProcess AS LONG.
END.

 PROCEDURE IsWow64Process EXTERNAL "kernel32.dll":
  DEFINE INPUT PARAMETER hProcess AS LONG.
  DEFINE INPUT-OUTPUT PARAMETER Wow64Process AS HANDLE TO LONG.
  DEFINE RETURN PARAMETER resultValue AS LONG.
END.

The following table lists the additional built-in preprocessor names that apply to SpeedScript.

Examples

The r-prprc1.p procedure shows how you can reference a built-in preprocessor name and include it in a character string.

r-prprc1.p

MESSAGE "The current operating system is" "{&OPSYS}." 
  VIEW-AS ALERT-BOX.

The procedure r-prprc2.p shows how to capture the value of a {&SEQUENCE} reference. In this example, {&SEQUENCE} is referenced three times, once each to assign its value to wvar (0) and xvar (1) at run time. The third reference defines the preprocessor name Last-Value with the value 3. As shown, Last-Value is assigned unchanged to both yvar and zvar, each of which takes the value 3 at run time.

r-prprc2.p

DEFINE VARIABLE wvar AS INTEGER NO-UNDO.
DEFINE VARIABLE xvar AS INTEGER NO-UNDO.
DEFINE VARIABLE yvar AS INTEGER NO-UNDO.
DEFINE VARIABLE zvar AS INTEGER NO-UNDO.

ASSIGN
  wvar = {&SEQUENCE}
  xvar = {&SEQUENCE}.

&GLOBAL-DEFINE Last-Value {&SEQUENCE}

ASSIGN
  yvar = {&Last-Value}
  zvar = {&Last-Value}.

MESSAGE "wvar =" wvar SKIP "xvar =" xvar SKIP
        "yvar =" yvar SKIP "zvar =" zvar VIEW-AS ALERT-BOX.

The procedure r-prprc3.p shows how preprocessor names override compile-time arguments. In this example, r-prprc3.p defines the preprocessor name My-Name as "Daniel". It then passes the compile-time argument My-Name, with the value "David", to the include file r-prprc3.i, which in turn defines a preprocessor name My-Name as "Donald".

r-prprc3.p

&SCOPED-DEFINE My-Name "Daniel"
{r-prprc3.i &My-Name = "David"}
MESSAGE "My-Name preprocessed in r-prprc3.p is" {&My-Name} + "."
  VIEW-AS ALERT-BOX.

r-prprc3.i

MESSAGE "My-Name argument in r-prprc3.i is" "{&My-Name}" + "." 
  VIEW-AS ALERT-BOX.
&SCOPED-DEFINE My-Name "Donald"
MESSAGE "My-Name preprocessed in r-prprc3.i is" {&My-Name} + "." 
  VIEW-AS ALERT-BOX

During execution, the first message included by r-prprc3.i displays the value of the My-Name argument, "David". The second message included by r-prprc3.i displays the value of the following My-Name preprocessor name, defined as "Donald", permanently overriding "David" passed by the My-Name argument. Finally, the message in r-prprc3.p displays the value of the My-Name preprocessor name that was initially defined there, "Daniel", because the value from My-Name established in r-prprc3.i ("Donald") went out of scope during compilation.

Note also that the reference to the My-Name compile-time argument in r-prprc3.i is inside double-quotes, because ABL passes string constant values for compile-time arguments without the surrounding double-quotes.

You can encounter compilation problems mixing preprocessor names with compile-time argument names. The following example, a variation of r-prprc3.i, does not compile, even when passed a My-Name argument as an include file. This is because the preprocessor My-Name value overrides the argument My-Name value, as shown:

&SCOPED-DEFINE My-Name "Donald"
MESSAGE "My-Name preprocessed in r-prprc3.i is" {&My-Name} + "."
  VIEW-AS ALERT-BOX.
MESSAGE "My-Name argument in r-prprc3.i is" "{&My-Name}" + "."
  VIEW-AS ALERT-BOX.

Because the preprocessor My-Name defines a quoted "Donald" value, ABL replaces "{&My-Name}" in the fourth line with ""Donald"". This appears to the compiler as two empty strings and an unknown variable reference (Donald). Although you can do it with care, in general, avoid using the same names for compile-time arguments and preprocessor names.

Notes

• ABL expands preprocessor names wherever and in whatever context it finds them, including inside quoted character strings.
• If you define a preprocessor name in the same file and with the same name as a compile-time argument passed to the file, the value of the preprocessor name takes precedence over the value of the argument name from the point where the preprocessor name is defined.

See also

&GLOBAL-DEFINE preprocessor directive, &SCOPED-DEFINE preprocessor directive, { } Argument reference, { } Include file reference, ; Special character