|
Note:
|
When you change the definition of a class, Progress Software Corporation recommends that you recompile all classes that inherit the modified class. This recommendation does not apply to method logic changes within a class.
|
COMPILE { procedure-pathname | class-pathname | VALUE ( expression ) }
[ ATTR-SPACE [ = logical-expression ] ]
[ SAVE [ = logical-expression ]
[ INTO { directory | VALUE ( expression ) } ]
]
[ LISTING { listfile | VALUE ( expression ) }
[ APPEND [ = logical-expression ]
| PAGE-SIZE integer-expression
| PAGE-WIDTH integer-expression
]
]
[ XCODE expression ]
[ XREF { xreffile | VALUE ( expression ) }
[ APPEND [ = logical-expression ] ]
]
[ XREF-XML { directory | filename | VALUE ( expression ) }
]
[ STRING-XREF { sxreffile | VALUE ( expression ) }
[ APPEND [ = logical-expression ] ]
]
[ STREAM-IO [ = logical-expression ] ]
[ LANGUAGES ( { language-list | VALUE ( expression ) } )
[ TEXT-SEG-GROW = growth-factor ] ]
[ DEBUG-LIST { debugfile | VALUE ( expression ) } ]
[ PREPROCESS { preprocessfile | VALUE ( expression ) } ]
[ NO-ERROR ]
[ V6FRAME [ = logical-expression ]
[ USE-REVVIDEO | USE-UNDERLINE ] ]
[ MIN-SIZE [ = logical-expression ] ]
[ GENERATE-MD5 [ = logical-expression ] ]
|
Specifies the name and location of a procedure file you want to compile, where procedure-pathname is the literal procedure pathname and
expression is a character expression that evaluates to the procedure pathname. This pathname can be a full (absolute) pathname or it can be a pathname (or procedure filename only) relative to PROPATH. The specified procedure filename must include the extension (
.p or
.w) whether you specify it alone or as part of a path. On UNIX, filenames are case sensitive, so you must enter them exactly as they are stored.
Specifies the name and location of a class definition file you want to compile. This can be a literal full (absolute) pathname or a literal pathname relative to PROPATH. If it is a relative pathname, the class or interface type name defined in the file must match the pattern of this relative pathname. If the type name is not defined with a package, the relative pathname must specify only the class filename. In all cases, the class filename must include the
.cls extension. On UNIX, the
class-pathname and corresponding class or interface type name are also case sensitive and must match in letter case as well as spelling. For more information on packages and class or interface type names, see the
Type-name syntax reference entry.
Decrypts the source code in procedure-pathname or
class-pathname, and any encrypted include files, using the decryption key
expression.
|
|
If XCODE is not present and there is no session key, the COMPILE statement uses the default key. If the default key does not match the source file key, then the compilation fails with an error message. If a session key is in effect and you want a COMPILE statement to use the default key, then you must unset the XCODE-SESSION-KEY attribute by setting it to the Unknown value ( ?) before executing the COMPILE statement.
|
|
|
The XCODE utility does not perform code page conversions and does not use the -cpinternal parameter when encrypting files. Therefore, the source code and key will use the default codepage of the operating system where you run the XCODE utility. If a different codepage is in effect where XCODE-SESSION-KEY is set, then codepage conversions may prevent the attribute key from matching the XCODE utility key and the compile fails. To prevent this case, use only US-ASCII characters, which are found in all code pages below code point 128.
|
If you specify a logical-expression, its value determines whether the STREAM-IO option is activated. If the
logical-expression is evaluated to the Unknown value (
?), a run‑time error occurs.
SAVE [ = logical-expression ] [ INTO
{ directory | VALUE (
expression)
} ]
These r‑code files are saved across ABL sessions. If you do not use the SAVE phrase, the COMPILE statement produces r‑code for the source procedure or class, but the r‑code is not saved across ABL sessions. This r‑code is a session-compile version of the procedure or class.
If you specify a logical-expression, its value determines whether the SAVE option is activated. If the
logical-expression is evaluated to the Unknown value (
?), a run‑time error occurs.
The COMPILE SAVE statement produces r‑code files with the name
procedure-pathname.r or
class-pathname.r, where
procedure-pathname is the pathname of a procedure source file without the filename extension, and
class-pathname is the pathname of a class source file without the filename extension. ABL ignores the filename extension of a procedure or class definition file and always creates r‑code files that use the same filename with a
.r extension. For example, if you supply a filename of
test,
test.p, or
test.cls, COMPILE SAVE produces an r‑code file with the name
test.r. If you specify a filename of
test.bp, COMPILE SAVE still produces an r‑code file with the name
test.r.
By default, the r‑code file is stored in the same directory as the source file. The r-code files for inherited (super) class definition files are also stored in the same directory as their respective source files.
If you use the SAVE INTO phrase, r‑code files produced by a compilation can be saved in a different directory. See the Examples section and the Notes section of this reference entry for more information.
LISTING { listfile | VALUE (
expression )
}
The listfile or VALUE (
expression ) identifies the name of the file in which you want to store the Compiler listing. If
expression evaluates to the Unknown value (
?), then ABL ignores the LISTING option.
APPEND [ =
logical-expression ]
If you specify a logical-expression, its value determines whether the APPEND option is activated. If the
logical-expression is evaluated to the Unknown value (
?), a run‑time error occurs.
XREF { xreffile | VALUE (
expression )
}
[ APPEND
[ = logical-expression ] ]
Writes cross‑reference information between procedures and ABL objects, or between class or interface definition files and ABL objects, to the file
xreffile or VALUE (
expression ). If
expression returns the Unknown value (
?), then ABL ignores the XREF option.
Cross‑referenced objects include procedure and include files, user‑defined functions, classes, methods, database tables, shared temp-tables, fields, variables, frames, and character strings. XREF generates one unformatted, whitespace‑separated line in
xreffile for each referenced object. Each line has the following format:
source-name file-name line-number reference-type object-identifier
|
The source-name is the name of the procedure or class file you compile with the COMPILE XREF statement. The
file-name is the name of the file with the referenced code. The
line-number is the line number of the statement in
file-name that contains the referenced object. The
reference-type is the type of reference in the code (such as ACCESS or UPDATE), and the
object-identifier is the ABL object being referenced.
|
Note:
|
If file-name is an include file, source-name is the file that includes the include file.
|
|
|
|
|
|
{ [ DATA-MEMBER ] [ database. ] table field
[ WORKFILE | TEMPTABLE ] } |
{ SHARED variable } |
{ PUBLIC-DATA-MEMBER class-name:data-member-name } |
{ INHERITED-DATA-MEMBER
class-name:data-member-name } |
{ PUBLIC-PROPERTY
class-name:property-name } |
{ INHERITED-PROPERTY
class-name:property-name } |
{ sequence-name SEQUENCE }
|
|
|
string
|
|
|
[ FROM source-class-name ]
TO target-class-name
|
|
|
class-name,[ INHERITS inherited-class-name
[ (inherited-class-name ...) ] ],
[ IMPLEMENTS interface-name
[ interface-name ]... ],
[ USE-WIDGET-POOL ], [ FINAL ], [ ABSTRACT ]
|
|
|
procedure | class-file
|
|
|
{ { PUBLIC, | PROTECTED, }
| { , STATIC } },,,constructor-name,
void, [ parameter1 [ , parameter2 ]... ]
|
|
|
code‑page‑name-that-ABL-uses‑in‑memory
|
|
|
code‑page‑name-that‑ABL‑uses‑for‑stream‑I/O
|
|
|
{ [ DATA-MEMBER | INHERITED-DATA-MEMBER ]
class-name:table-name } |
[ database. ] table [ WORKFILE |
TEMPTABLE ] }
|
|
|
{ PUBLIC | PROTECTED }, [ STATIC ],
[ TEMPTABLE | BUFFER | QUERY |
DATASET | DATASOURCE ],
data-member
|
|
|
dataset-name, { PROTECTED },
[ REFERENCE-ONLY ],
[ NAMESPACE-URI namespace ],
[ NAMESPACE-PREFIX prefix ],
buffer-name1 [ [ buffer-name2 ]... ], [DATALINKS]
|
|
|
{ [ DATA-MEMBER | INHERITED-DATA-MEMBER ]
class-name:table } |
[ database. ] table [ WORKFILE | TEMPTABLE ]
|
|
|
class-name
|
|
|
PUBLIC,,,,destructor-name,void,
|
|
|
procedure-name,,
[ parameter1 [ , parameter2 ]... ]
|
|
|
function-name,return-type,
[ parameter1 [ , parameter2 ]... ]
|
|
|
{ PUBLIC | PROTECTED }, [ STATIC ],
[ OVERRIDE ],,[ ABSTRACT ], event-name,
[ delegate-type-name ], return-type,
[ parameter1 [ , parameter2 ]... ]
|
|
|
Not applicable (Data Servers only)
|
|
|
function-name,return-type,
[ parameter1 [ , parameter2 ]... ]
|
|
|
global-variable
|
|
|
include-file-name
|
|
|
interface-type-name,
[ INHERITS interface-type-name
[ (interface-type-name ...)]],,,
|
|
|
class-name:method-name
[ , invocation-parameter1
[ , invocation-parameter2 ]... ]
|
|
|
{ PUBLIC | PROTECTED }, [ STATIC ],
[ OVERRIDE ], [ FINAL ], [ ABSTRACT ],
method-name, return-type,
[ parameter1 [ , parameter2 ]... ]
|
|
|
class-name [ , invocation-parameter1
[ , invocation-parameter2 ]... ]
|
|
|
dataset-name, { PROTECTED },
[ REFERENCE-ONLY ],
[ NAMESPACE-URI namespace ],
[ NAMESPACE-PREFIX prefix ],
buffer-name1 [ [ buffer-name2 ]... ],
[ DATALINKS ]
|
|
|
new-shared-frame
|
|
|
temptable-name
|
|
|
new-shared-variable
|
|
|
new-shared-workfile
[ LIKE [ database. ] table ]
|
|
|
procedure-name,,
[ parameter1 [ , parameter2]... ]
|
|
|
function-name, return-type,
[ parameter1 [ , parameter2 ]... ]
|
|
|
procedure-name,,
[ parameter1 [ , parameter2 ]... ]
|
|
|
{ PUBLIC | PROTECTED }, [ STATIC ],
[ OVERRIDE ],,[ ABSTRACT ], property-name
|
|
|
[ class-name: ] event-name | (exp)
|
|
|
{ [ database. ] table [ field ]
[ WORKFILE ] } | { SHARED variable |
{ [ DATA-MEMBER | INHERITED-DATA-MEMBER ]
class-name:table [ field ] }
|
|
|
procedure-name | value(exp)
[ PERSISTENT | REMOTE | SUPER | STORED-PROC ]
|
|
|
{ [ database. ] table |
{ [ DATA-MEMBER | INHERITED-DATA-MEMBER ]
class-name:table } } { WORKFILE |
{ { index | RECID } [ TEMPTABLE ]
[ WHOLE-INDEX | TABLE-SCAN ] } }
|
|
|
dataset-name, { PROTECTED },
[ REFERENCE-ONLY ],
[ NAMESPACE-URI namespace ],
[ NAMESPACE-PREFIX prefix ],
buffer-name1 [ [ buffer-name2 ]... ],
[ DATALINKS ]
|
|
|
shared-frame
|
|
|
temptable-name
|
|
|
shared-workfile [ LIKE [ database. ] table ]
|
|
|
{ [ database. ] table field
[ WORKFILE | TEMPTABLE ] }
|
|
|
{ FOR EACH | OPEN QUERY } table BY expression
|
|
|
char-string max-length justification
translatable [ FORMAT ]
|
|
|
[ class-name: ] event-name | (exp)
[ , [ class-name: ] handler-name
[ , parameter1 [ , parameter2 ]... ] ]
|
|
|
[ class-name: ] event-name | (exp) | ALL
[ , [ class-name: ] handler-name
[ , parameter1 [ , parameter2 ]... ] ]
|
|
|
{ [ DATA-MEMBER ] [ database. ] table field
[ WORKFILE | TEMPTABLE ] } |
{ SHARED variable } |
{ PUBLIC-DATA-MEMBER
class-name:data-member-name } |
{ INHERITED-DATA-MEMBER
class-name:data-member-name } |
{ PUBLIC-PROPERTY
class-name:property-name } |
{ INHERITED-PROPERTY
class-name:property-name } |
{ sequence-name SEQUENCE }
|
{ INPUT | INPUT-OUTPUT | OUTPUT }
{ [ data-type [ EXTENT [ constant ] ] |
TABLE temp-table-name |
TABLE-HANDLE |
DATASET dataset-name |
DATASET-HANDLE |
TABLE-REFERENCE |
DATASET-REFERENCE |
RUNTYPE }
|
The invocation parameters will be listed for every constructor or method invocation that has arguments. If a method or constructor is overloaded, invocation parameters can be used to determine which version of the method or constructor is being invoked. If the compiler has not resolved the method call (that is, it has deferred resolution to run time), one or more of the invocation parameters may be identified as TABLE REFERENCE, DATASET REFERENCE, or RUNTYPE. This label indicates that the argument being passed matches the type of the corresponding parameter in more than one of the candidate overloads.
|
|
In contrast to PUBLIC-DATA-MEMBER, INHERITED-DATA-MEMBER indicates that a line of code references a data member inherited by the class in which the reference appears. DATA-MEMBER in an UPDATE or ACCESS entry indicates that a line of code references a temp-table or related object that has been defined in the class in which the reference appears. Properties are treated similarly.
|
|
|
In the CLASS entry, INHERITS inherited-class-name indicates the immediate super class of the class, if any exists. If the super class inherits from one or more classes, the names of these classes will appear following the name of the immediate super class of the compiled class. Each inherited class name will be separated from the preceding one by a space.
|
|
|
If a class has a super class but does not explicitly execute the SUPER statement in its constructor, the ABL compiler adds an implicit SUPER invocation to the r-code. When this happens, there will be an INVOKE entry generated for the implicit SUPER invocation. This entry indicates that the name of the method being invoked is super-class-type-name: class-name (the constructor name). Instead of a line number, the entry will use the label IMPLICIT.
|
|
|
Note that field for REFERENCE is optional. It will not appear if the corresponding line of code is either VALIDATE temp-table or RELEASE temp-table.
|
|
|
If a class has as a data member an ABL handle and code uses that handle to call a built-in ABL method or to set or get a built-in attribute, the XREF output will include just an ACCESS entry and the entry will identify only the name of the handle data member, not the method or attribute involved. (This is similar to how XREF handles SHARED variables that are handles.)
|
|
|
If you specify the APPEND option, the cross‑reference information is appended to an existing file. The first line of cross‑reference information for a procedure contains the object identifier for the COMPILE reference type. This allows you to easily find where the information for each compilation begins. If you specify a logical-expression, its value determines whether the APPEND option is activated. If the logical-expression is evaluated to the Unknown value ( ?), a run‑time error occurs.
|
XREF-XML { directory | filename | VALUE (
expression )
}
Writes the cross-reference string information to a formatted XML file. The standard XREF option writes the information to an unformatted text file. The XREF-XML option provides structured output that is formatted with whitespace for easier parsing by humans. More importantly, this option exposes the cross-reference information in a format that developers can exploit with custom-built tools or visualize in a ProDataset or a .NET dataset.
Table 17 and the accompanying documentation in the XREF option section defines the cross reference and identifier labels used with both the standard XREF and the XREF-XML options.
STRING-XREF { sxreffile | VALUE (
expression )
} [ APPEND
[ = logical-expression ] ]
Writes cross‑reference string information between procedures and ABL objects, or between class definition files and ABL objects, to the file
sxreffile or VALUE (
expression ). If
expression evaluates to the Unknown value (
?), ABL ignores the STRING-XREF option.
The x.y is a major.minor version number, where a major version change implies a formatting change that will not be backward compatible with older versions of TranManII. The
source-file is the name of the file from which the strings are extracted. The
code-page is the code page with which the file was written.
line‑number object‑name string max‑length string‑justification statement‑type detail‑info
|
The line‑number is the same as
line‑number in the standard XREF file. The
object‑name is the name of the object with which the string is associated. The
max‑length and
string‑justification come from the string attribute (either explicit or implicit) and reflect the attributes applied to the string as it is entered into the text segment.
The statement‑type describes the type of statement in which the string appears. Only one statement type appears in a given string’s output line. The values in the following table are possible:
The detail‑info is one or more detail tags that specify more specifically where the string appears in the statement. The values in the following table are possible:
|
Note:
|
The NON‑ALPHA tag indicates that a string consists entirely of blanks or digits. The FORMAT tag is followed by one of the following tags: CHAR, NUMERIC (includes decimal and integer), DATE, or BOOL. These tags indicate the type of format. When a string can appear in only one place in a statement, no detail tag appears.
|
Table 18 shows the valid combinations of statement types and detail tags.
Identifies which language segments to include in the compiled r‑code. The
language-list is a colon‑separated list of language names used to generate each text segment. If you specify VALUE (
expression ), the expression must evaluate to a comma‑separated list of language names. If
expression evaluates to the Unknown value (
?), then ABL ignores the LANGUAGES option.
In this example, the compiler searches the translation database for French‑Canadian translations. If a French‑Canadian translation is not found, the compiler searches for a French translation. If a French translation is not found, the compiler searches for an English translation. If an English translation is not found, the compiler uses the strings from the source code.
This example generates four text segments: French‑Canadian, Portuguese, New‑York, and the unnamed (default) text segment. The first language name in each
language-list argument designates the name of the text segment and specifies the first language that the compiler looks up in the translation database. As a result, it is possible to create a text segment whose name has no relationship to the languages it is composed of. For example, the following argument creates a text segment named
BABEL:
|
|
growth-factor is the value specified with the TEXT-SEG-GROW option.
|
|
|
table-value is the appropriate percentage from the following table:
|
Writes the debug listing to the file debugfile or VALUE (
expression ). If
expression evaluates to the Unknown value (
?), then ABL ignores the DEBUG-LIST option. The
debugfile consists of a line‑numbered listing of the procedure with the text of all preprocessor include files, names, and parameters inserted.
PREPROCESS { preprocessfile | VALUE (
expression )
}
Preprocesses the procedure or class definition file and writes the preprocessed source code to the file
preprocessfile or VALUE (
expression ). If
expression evaluates to the Unknown value (
?), ABL ignores the PREPROCESS option. The
preprocessfile is a text file that contains a final version of your source code after all include files have been inserted and all text substitutions have been performed.
V6FRAME [ = logical-expression ] [USE-REVVIDEO
| USE-UNDERLINE
]
The V6FRAME option is designed specifically to compile and run Progress Version 6 applications with Progress Version 7 or later in Windows. This option uses the V6FontNumber setting in the [Startup] section of the current environment (which might be the Registry or an initialization file) to calculate the height and width of a character unit and then set the layout grid used to compile frames for display in Progress Version 7 or later.
|
|
USE-REVVIDEO displays no border around a fill‑in field. When a fill‑in is enabled for input, the color of the fill‑in changes to the color specified with the INPUT setting in the [Colors] section in the current environment (which might be the registry or an initialization file). The IBEAM cursor signals that a fill‑in field has input focus.
|
|
|
USE-UNDERLINE displays no border around a fill‑in widget. When a fill‑in is enabled for input, the underline attribute of the font (V6FontNumber) for the fill‑in is turned on. The color of a fill‑in enabled for input does not change. The IBEAM cursor signals that a fill‑in field has input focus.
|
If you specify a logical-expression, its value determines whether the V6 compile option is activated. If the
logical-expression is evaluated to the Unknown value (
?), a run‑time error occurs.
If you specify a logical-expression, its value determines whether the MIN-SIZE option is activated (TRUE) or not (FALSE). If the
logical-expression evaluates to the Unknown value (
?), a run‑time error occurs. The default value is FALSE.
When ABL compiles a procedure or class definition file with the GENERATE-MD5 option, it generates a special MD5 value based on the code content, and stores it in the r-code file. This r-code MD5 value is similar to a CRC value, except the MD5 value is 128 bits in size and the CRC value is only 16 bits. The MD5 value is virtually guaranteed to be different if the file content has changed. As with CRC, content changes include any schema changes. That is, if only the schema changes, the MD5 value also changes.
If you specify a logical-expression, its value determines whether the GENERATE-MD5 option is activated (TRUE) or not (FALSE). The default value is TRUE.
This option is supported for WebClient™ only (that is, only WebClient uses the resulting MD5 value). Progress Software Corporation recommends compiling your WebClient application procedures with this option. Using this option lets WebClient determine if an r-code file has changed since the previous version of the application.
In this procedure, ABL compiles the ord-ent procedure, produces an r‑code file,
ord-ent.r, that can be used across ABL sessions, and saves the r‑code file in the current directory:
You can save the r‑code file in a different directory by using the SAVE INTO phrase. For example, to save an r‑code file in
/usr/sources on a UNIX system, enter this command:
|
1.
|
{} — The level of the include file
|
|
2.
|
Line — The line number in the file
|
|
3.
|
Blk — The number of the block
|
|
|
Line — The line number where the block starts
|
|
|
Blk. Type — The type of block (Procedure, DO, FOR EACH, REPEAT)
|
|
|
Tran — Whether the block is a transaction block
|
|
|
Buffers — The name of the record buffer scoped to the block
|
|
|
Frames — The name of the frame scoped to the block
|
Each line in the xref file specifies the procedure, line number, access type, and access information. The first line in the
xref file contains the COMPILE access type directive and the name of the procedure exactly as it appears in the COMPILE statement. See
Table 17 for a list of the values that follow a particular access type (for example,
table and
index after SEARCH).
If you modified r-comlis.p to use the XREF-XML option instead of XREF, your cross reference file would be named
r-comlis.xref.xml. The structured formatting of XML would use many more lines to display the same information on one line of standard XREF output. Here is a small snippet of that file:
...
<Reference Reference-type="INCLUDE" Object-identifier=""c:\openedge\wrk\r-fcust.i"">
<Source-guid>9+5Nn2plMK7bEdVPTNq+Gw</Source-guid>
<File-num>1</File-num>
<Ref-seq>6</Ref-seq>
<Line-num>4</Line-num>
<Object-context />
<Access-mode />
<Data-member-ref />
<Temp-ref />
<Detail />
<Is-static>false</Is-static>
<Is-abstract>false</Is-abstract>
</Reference>
<Reference Reference-type="INCLUDE" Object-identifier=""c:\openedge\wrk\r-dcust.i"">
<Source-guid>9+5Nn2plMK7bEdVPTNq+Gw</Source-guid>
<File-num>1</File-num>
<Ref-seq>13</Ref-seq>
<Line-num>5</Line-num>
<Object-context />
<Access-mode />
<Data-member-ref />
<Temp-ref />
<Detail />
<Is-static>false</Is-static>
<Is-abstract>false</Is-abstract>
</Reference>
<Reference Reference-type="STRING" Object-identifier="Cust Num">
<Source-guid>9+5Nn2plMK7bEdVPTNq+Gw</Source-guid>
<File-num>1</File-num>
<Ref-seq>17</Ref-seq>
<Line-num>6</Line-num>
<Object-context />
<Access-mode />
<Data-member-ref />
<Temp-ref />
<Detail />
<Is-static>false</Is-static>
<Is-abstract>false</Is-abstract>
<String-ref>
<Source-guid>9+5Nn2plMK7bEdVPTNq+Gw</Source-guid>
<Ref-seq>17</Ref-seq>
<Max-length>8</Max-length>
<Justification>LEFT</Justification>
<Translatable>true</Translatable>
</String-ref>
</Reference>
...
|
<Reference Reference-type="INTERFACE" Object-identifier="interface-name">
<Source-guid>7mu7M0PmmZ0R3/Mtc60gbA</Source-guid>
<File-num>1</File-num>
<Ref-seq>4</Ref-seq>
<Line-num>4</Line-num>
<Object-context/>
<Access-mode/>
<Data-member-ref/>
<Temp-ref/>
<Detail/>
<Is-static>false</Is-static>
<Is-abstract>false</Is-abstract>
<Interface-ref>
<Source-guid>7mu7M0PmmZ0R3/Mtc60gbA</Source-guid>
<Ref-seq>4</Ref-seq>
<Inherited-list/>
</Interface-ref>
</Reference>
|
<Reference Reference-type="INTERFACE" Object-identifier="interface-name">
<Source-guid>7mu7M0PmmZ0R3/Mtc60gbA</Source-guid>
<File-num>1</File-num>
<Ref-seq>4</Ref-seq>
<Line-num>4</Line-num>
<Object-context/>
<Access-mode/>
<Data-member-ref/>
<Temp-ref/>
<Detail/>
<Is-static>false</Is-static>
<Is-abstract>false</Is-abstract>
<Interface-ref>
<Source-guid>7mu7M0PmmZ0R3/Mtc60gbA</Source-guid>
<Ref-seq>4</Ref-seq>
<Inherited-list/>acme.inventory.IWarehouse(acme.inventory.IStoreRoom acme.inventory.IShelf)]</Inherited-list>
</Interface-ref>
</Reference>
|
|
|
Two additional startup parameters are available that can affect the behavior of the COMPILE statement: Compile Warning List ( -cwl) and Keyword Forget List ( -k). The Compile Warning List option lets you specify a set of ABL statements that trigger compile-time warnings if they are found in the source code. The Keyword Forget List option lets you disable specified keywords, allowing you to compile code in which those keywords occur as ABL user-defined element names, such as table, field, variable, and procedure names. For more information about these startup parameters, see OpenEdge Deployment: Startup Command and Parameter Reference.
|
|
|
The value of the PROPATH environment variable defines the list of directories (path) to use when searching for a procedure.
|
|
|
On UNIX, you define the PROPATH variable in a startup script or in your .profile file. In Windows, you can define your PROPATH in the Registry or in an initialization file. You can also define the PROPATH interactively at the operating system level.
|
|
|
To locate the source file that you name in the COMPILE SAVE statement, ABL searches the first directory in PROPATH. If the source file is there, ABL compiles the source file and creates an r‑code file. On UNIX, this new r‑code file replaces any existing r‑code file. If errors occur during compilation, ABL does not produce an r‑code file and leaves existing r‑code files unchanged.
|
When you use the SAVE INTO phrase to store compiled r-code files for one or more class definition files specified with a package, ABL creates a directory structure under the specified SAVE INTO directory that is consistent with the directory structure of the original source files relative to
PROPATH (if the directory structure doesn’t already exist). That is, ABL creates a subdirectory under the specified SAVE INTO directory to match the original source directory for each class definition file in the hierarchy.
|
|
It must have the same cyclic redundancy check (CRC) value as any database tables it references, or the same time stamp if you are running with the Timestamp (-tstamp) parameter. When creating an r‑code file, ABL includes, as part of the r‑code file, either the CRC or the time stamp of the most recent change to the database schema that affects this procedure (for example, adding or deleting a field or index definition in a table that the procedure references).
|
If there is a usable r‑code file, there is no reason to perform the compilation. You receive an error and the compilation stops unless you have specified the XREF, LISTING, PREPROCESS, or DEBUG-LIST option. If you specified one of these options, ABL continues with the compilation and produces the files specified and a session compile. If ABL does create a session compile version, the version is not used when you use the RUN statement. The RUN statement always uses an existing r‑code file before using a session compile version of a procedure.
If there is no usable r‑code file, ABL searches the same directory in
PROPATH for a source file. If the source file is there, ABL compiles it into the session compile file. If it is not there, ABL continues on to the next directory in
PROPATH, searching for an r‑code file, then for a source file.
|
|
The size of the r‑code might vary, depending on the window system on which it is compiled.
|
|
|
Modifications to existing field definitions do not affect database table CRC or time‑stamp values. Therefore, updating a table’s existing field definitions does not invalidate r‑code versions of procedures that reference the table. However, adding or deleting tables, fields, or indexes does affect database table CRC and time stamps. This invalidates r‑code versions of procedures that reference the changed tables.
|
|
|
A WHOLE-INDEX search reported for a table occurs when an entire index is used to search the table. (That is, the bracket used by the query to search the table spans the entire index.) This can occur either when no selection criteria are specified to limit the range of index keys searched (that is, to bracket a subset of the index) or when there is no appropriate index available to optimize the selection criteria. For example, the following queries on Customer table of the sports2000 database both result in WHOLE-INDEX searches. The first query uses the Name index to search the entire table, returning every record in Name order. The second query uses the primary index to search the entire table because there is no index provided for the Balance field to limit the search.
|
