VisualAge Generator to Enterprise Generation Language Migration Guide


Statements

The statements section is organized into the following tables:


Figure 96. Statements - General rules - data item qualification and numeric literals

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations

Data item qualification rules: If an item is not qualified, VisualAge Generator looks for the item in the following order:

  • Items in the function's local storage or parameter list.
  • The function's I/O object and records in the function's local storage or parameter list. If the item name is not unique in this category, the item name must be qualified.
  • Records, maps, and tables in the program's primary working storage record, called parameter list, table and additional records list, and all I/O objects. If the item name is not unique in this category, the item name must be qualified.
  • If the item name is not found within the program and the program allows implicit items, VisualAge Generator creates a data item definition based on the use of the item.

Data item qualification rules: If an item is not qualified, EGL looks for the item in the following order:

  • Items in the function's local storage or parameter list.
  • The records and forms used in the function's I/O statements and records in the function's local storage or parameter list. If the item name is not unique in this category, the item name must be qualified.
  • Records, forms, and tables in the program's data declarations, use declarations, and parameter list. If the item name is not unique in this category, the item name must be qualified.
  • EGL does not permit implicit items. Every item must be explicitly defined.

See Level 77 items in recordsand Implicit data items in programs for details and potential problems.

Numeric literals:
  • Not enclosed in quotes.
  • Can use either a period (.) or a comma (,) as the decimal point, depending on the national language.
Numeric literals:
  • Not enclosed in quotes.
  • Must use the period as the decimal point. At generation time, the decimalSymbol build descriptor option determines whether the period or comma is used as the decimal point in the generated Java or COBOL code.
The migration tool converts the commas used as decimal points to a period except for initial values of form variable fields.

Figure 97. Statements -- Function invocation

VisualAge Generator4.5
EGL produced by the migration tool Migration tool considerations
VAGen syntax example:
functionName( [argumentList] );
EGL syntax example:
functionName( [argumentList] );

See EZE words for the EGL equivalent system library functions.

See Figure 91 for function invocations from an I/O error routine.

In flow statements:
functionName();
Flow statements are not supported.
goto functionName;
No special considerations.

Figure 98. Statements -- Assignment, MOVE, and MOVEA

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
VAGen syntax example:
target = functionName
          ( [argumentList] ) ;
EGL syntax example:
target = functionName
          ( [argumentList] ) ;
See EZE words for the EGL equivalent system library functions.
target = numericExpression;
or
target = numericExpression (R;
target = numericExpression ;
or
target = sysLib.round
          ( numericExpression ) ;
If the (R option is specified, the migration tool converts the option to the EGL round system function.
target = source;
or
MOVE source [ TO ] target;
Note:
  • The target can be a record, map, data item, or certain EZE data words.
  • The source can be a record, map, literal, data item, or certain EZE data words.
  • If the target is a record or map, the source must also be a record or map. A move corresponding occurs.
target = source ; 
or
move source to target byName ;
or
move source to target ;
Note:
  • For assignment statements:
    • The target can be a record, data item, or certain system variables. If the target is a record, the source must also be a record; the source is moved to the target on a byte-by-byte basis.
    • The source can be a record, literal, data item, or certain system variables.
    • Forms cannot be used in assignment statements.
    • Move corresponding is never done for an assignment statement.
  • For move statements:
    • The target and source can be the same as in VisualAge Generator assignment or MOVE statements.
    • If byName is specified, EGL does a move corresponding.
    • If no modifier is specified, the move is either an item to item move or a move corresponding depending on the part type of the source.
The data conversion and truncation rules are the same as in VisualAge Generator.

The migration tool considers the following EGL rules when migrating assignment and move statements:

  • EGL prefers that the assignment statement be used for item-to-item moves.
  • The move byName statement is required for moves involving records or forms to preserve the VAGen move corresponding behavior.
  • Move without a modifier is tolerated and treated as an item-to-item move or a move corresponding depending on the part type of the source.

Therefore, the migration tool does the following:

  • Converts to an assignment statement for any of the following:
    • The source or target is an EZE data word (for example: EZEAPP).
    • The source is a literal.
    • The source or target is a qualified or subscripted item.
    • The source or target is an item in the function's parameter list or local storage.
  • Converts to a move byName if the source or target is the function's I/O object or a record in the function's parameter list or local storage.
  • Converts to a move without a modifier in all other situations.

See Assignment statements for details and potential problems.

MOVEA source [TO] target;
or
MOVEA source [TO] target
      FOR occurrence;
Note:
The source can be an array or a scalar.
move source to target for all ;
or
move source to target
     for occurrence ;

The migration tool converts the MOVEA statement to a move statement with the for modifier. The tool also does the following:

  • Includes the for all option if the FOR occurrence option was not specified in VisualAge Generator.
  • Includes the for occurrence option if the FOR occurrence option was specified in VisualAge Generator.
  • Sets the target subscript to 1 if the subscript was not previously specified.
  • Does not set the subscript to 1 for the source because the source can be an array or a scalar item.


Figure 99. Statements -- SET

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
General information:
  • Commas or blanks can be used to separate multiple options on a single SET statement.
General information:
  • Commas are required to separate multiple options on a single set statement.
No special considerations.
SET record SCAN;
 
OR
SET record EMPTY;
Note:
SET record EMPTY does not affect level 77 items.
set record position;
 
OR
set record empty;
The migration tool does not add a statement for the level 77 record.
SET sqlItem NULL;
Note:
sqlItem can be an item in an SQL row record or an SQLITEM parameter for a function.
set sqlItem null ;
Note:
sqlItem can be an isNullable=yes item in an SQL row record or a nullable parameter for a function.
No special considerations.
SET map [ ALARM |
        [ CLEAR | EMPTY] ] ;
Note:
  • CLEAR and EMPTY are mutually exclusive.
  • ALARM and either CLEAR or EMPTY can be combined with the PAGE option.
set form [alarm | 
         [ initial | empty ] ] ;
  • Initial and empty are mutually exclusive.
  • The replacement for the PAGE option cannot be combined with any other options.
If ALARM, CLEAR, or EMPTY are used in combination with the PAGE option, the migration tool splits the VAGen statement into two EGL statements.
SET map PAGE ;
Note:
PAGE can be combined with ALARM and with either CLEAR or EMPTY.
sysLib.clearScreen(); 
            // display form
or
sysLib.pageEject(); 
            // printer form
Note:
The replacement for the PAGE option cannot be combined with any other options.

The migration tool migrates SET map PAGE as follows:

  • If SET map PAGE is used in combination with any other options, the migration tool splits the VAGen statement into two EGL statements.
  • If the map is a display map, the migration tool converts the statement to sysLib.clearScreen();
  • If the map is a printer map, the tool converts the statement to sysLib.pageEject();
  • If the map is not available to determine the map type, the migration tool converts the statement to sysLib.EZE_SETPAGE();

See SET map PAGE statement for details and potential problems.

SET mapItem 
     [ CURSOR | FULL |
     [ NORMAL | DEFINED ] ] ;
Note:
  • mapItem can be an item on a map or a MAPITEM parameter for a function.
  • NORMAL and DEFINED are mutually exclusive.
  • CURSOR and FULL can be combined with either NORMAL or DEFINED.
  • VisualAge Generator tolerates setting CURSOR, FULL, NORMAL, and DEFINED for print maps, but they had no effect on the printed output.
set formField 
 [ cursor | full |
 [ normal | initialAttributes ] ] ;
Note:
  • formField can be a variable field on a form or a field parameter for a function.
  • normal and initialAttributes are mutually exclusive.
  • cursor and full can be combined with either normal or initialAttributes.
  • EGL does not support setting cursor, full, normal, or initialAttributes for print forms.

The migration tool migrates to the EGL equivalent of each option without regard to whether the formField is on a text or print form. See SET mapItem attributes for details and potential problems.

SET mapItem 
 [ CURSOR | FULL | 
   color | extendedHighlight |
   MODIFIED | 
  [ BRIGHT | DARK ] | 
  [ PROTECT | AUTOSKIP ] ] ;
Note:
  • mapItem can be an item on a map or a MAPITEM parameter for a function.
  • BRIGHT and DARK are mutually exclusive.
  • PROTECT and AUTOSKIP are mutually exclusive.
  • Any of the other options can be combined.
  • VisualAge Generator tolerates setting these attributes for print maps. However, only the extended highlighting option of USCORE has any effect on the printed output.
set formField
  [ cursor | fullcolor | extendedHighlight |
   modified |
  [ bold | invisible ] |
  [ protect | skip ] ] ;
Note:
  • formField can be a variable field on a form or a field parameter for a function.
  • Bold and invisible are mutually exclusive.
  • Protect and skip are mutually exclusive.
  • Any of the other options can be combined.
  • Except for the extended highlighting option of underline, EGL does not support setting these attributes for print forms.
The migration tool migrates to the EGL equivalent of each option without regard to whether the formField is on a text or print form. See SET mapItem attributes for details and potential problems. See later rows in this table for color and extendedHighlight information.
color:  MONO  | 
        BLUE | 
        GREEN |
        PINK | 
        RED |
        TURQ |
        YELLOW |
        WHITE
color:  defaultColor | 
        blue | 
        green |
        magenta | 
        red |
        cyan |
        yellow |
        white
No special considerations.
extendedHighlight: 
            NOHILITE | 
            BLINK | 
            RVIDEO |
            USCORE 
extendedHighlight: 
             noHighLight | 
             blink | 
             reverse |
             underline
No special considerations.

Figure 100. Statements -- RETRIEVE and FIND

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
RETR  dataItem1 
      table[.searchColumn]
      dataItem2 
      [ returnColumn ] ;
Note:
  • If the searchColumn is not specified, the default is the first column in the table.
  • If the returnColumn is not specified, the default is the second column in the table.
if (dataItem1 in 
   table.searchColumn)
 dataItem2table.returnColumn[sysVar.arrayIndex]; 
end
Note:
The searchColumn and returnColumn are required.

The migration tool converts the RETR statement to an if statement and an assignment statement.

Special considerations apply if the table is not available during migration. See RETR statement for details and potential problems.

FIND dataItem 
    table[.searchColumn] 
    trueStatement; 
 
 
OR
FIND  dataItem
    table[.searchColumn] 
    , falseStatement ;
 
 
OR
FIND  dataItem
    table[.searchColumn]
    trueStatement 
      [,]  falseStatement ;
Note:
  • If the searchColumn is not specified, the default is the first column in the table.
  • If FIND is used in program flow, the trueStatement and the falseStatement can be the name of a main function or EZECLOS.
  • If FIND is used in a function, the trueStatement and the falseStatement can be the name of any function, EZECLOS, EZEFLO, or EZERTN.
if (dataItem in table.searchColumn)
    EGLtrueStatement ;
end
 
 
OR
if (dataItem in table.searchColumn)
else
     EGLfalseStatement ; 
end
 
 
OR
if (dataItem in table.searchColumn)
   EGLtrueStatement ;
else
   EGLfalseStatement ;
end
Note:
The searchColumn is required.

The migration tool converts the FIND statement to an if statement and the EGL equivalent of the true and false statements. See later rows in this table for conversion of the trueStatement and falseStatement to the corresponding EGL statements.


true/falseStatement in flow:
  • functionName() (main only)
  • EZECLOS
Corresponding EGL replacements:
  • goto functionName;
  • exit program;
No special considerations.
true/falseStatement in a function:
  • functionName (any function)
  • EZECLOS
  • EZEFLO
  • EZERTN
Corresponding EGL replacements:
  • functionName();
  • exit program;
  • exit stack;
  • return;
No special considerations.

Figure 101. Statements -- IF, WHILE, and TEST, including EZEAID, EZESYS, and I/O error values

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
IF logicalExpression ;
   { statement ; }
[ ELSE;
   { statement ; } ]
END;
if ( EGLLogicalExpression )
   { EGLStatement ; }
[ else
   { EGLStatement ; } ]
end
See later rows in this table for the relationship between the VAGen logical expressions and the EGL logical expressions.
WHILE logicalExpression ;
   { statement ; }
END;
while ( EGLLogicalExpression )
   { EGLStatement ; }
end
See later rows in this table for the relationship between the VAGen logical expressions and the EGL logical expressions.
TEST testCondition 
     trueStatement ;
 
 
 
TEST testCondition 
     , falseStatement ;
 
 
 
 
TEST testCondition 
     trueStatement 
     [, ] falseStatement ;
Note:
  • The TEST statement is similar to an IF ... IS statement. The exception to this is TEST mapItem nnn, +nnn, and -nnn, which does not have an IF statement equivalent.
  • If TEST is used in program flow, the trueStatement and the falseStatement can be the name of a main function or EZECLOS.
  • If TEST is used in a function, the trueStatement and the falseStatement can be the name of any function, EZECLOS, EZEFLO, or EZERTN.
if ( EGLLogicalExpression )
   EGLtrueStatement ; 
end
 
if ( EGLLogicalExpression )
else
   EGLfalseStatement ; 
end
 
if ( EGLLogicalExpression )
  EGLtrueStatement ;
else
   EGLfalseStatement ;
end

With the exception of TEST mapItem nnn, +nnn, and -nnn, the migration tool converts the TEST statement to the equivalent if ... is statement and the EGL equivalent of the true and false statements.

See later rows in this table for the relationship between the VAGen logical expressions and the EGL logical expressions.

See later rows in this table for conversion of the trueStatement and falseStatement to the corresponding EGL statements.

VisualAge Generator boolean operators for IF and WHILE:
  • AND
  • OR
Corresponding EGL boolean operators for if and while:
  • &&
  • ||
No special considerations.
VisualAge Generator relational operators for IF and WHILE:
  • EQ and =
  • NE and ^=
  • LE and <= and =<
  • LT and <
  • GE and >= and =>
  • GT and >
Corresponding EGL relational operators for if and while:
  • =
  • !=
  • <=
  • <
  • >=
  • >
No special considerations.
VisualAge Generator state operators for IF and WHILE:
  • IS
  • NOT
Corresponding EGL state operators for if and while:
  • is
  • not
The migration tool always migrates a VAGen TEST statement to an EGL if ... is statement.
VisualAge Generator array operator for IF and WHILE:
  • IN
Corresponding EGL state operators for if and while:
  • in
No special considerations.
VisualAge Generator mapItem state conditions:

  • BLANK or BLANKS
  • CURSOR
  • DATA
  • MODIFIED
  • NULL or NULLS
  • NUMERIC
Corresponding EGL formField state conditions:
  • blanks
  • cursor
  • data
  • modified
  • blanks
  • numeric

The migration tool converts to the equivalent EGL state conditions.

Special considerations apply to mapItem NULL. See Checking SQL and map items for NULL for details and potential problems.

Special mapItem state condition for the TEST statement: nnn | +nnn | -nnn

Note:
This compares the length of the data the user entered to nnn. The test is =, >, or < corresponding to nnn, +nnn, or -nnn.

EGL does not provide direct support for this state condition. However, you can achieve the equivalent function by doing the following:

  • Use the system library function sysLib.fieldInputLength, which returns the length of the data entered by the user.
  • Use an if statement to compare the resulting length for = , >, or < corresponding to nnn, +nnn, or -nnn, respectively.

When migrating any program, the migration tool always includes a declaration for:

<custPrefix>EZE_ITEMLEN

The migration tool does the following for TEST nnn, +nnn, or -nnn:

  • Adds an extra statement just before the TEST statement to set
    <custPrefix>EZE_ITEMLEN
    

    using the system library function sysLib.fieldInputLength(item).

  • Changes the TEST statement to an if statement and compares
     <custPrefix>EZE_ITEMLEN
    

    to = nnn, > nnn, or < nnn.

VisualAge Generator map state conditions:
  • MODIFIED
Corresponding EGL form state conditions:
  • modified
No special considerations.
VisualAge Generator EZEAID state conditions:

  • ENTER
  • BYPASS
  • PAn, where n = 1, 2, 3
  • PFn, where n is 1 to 24
  • PA
  • PF
Corresponding EGL sysVar.eventKey state conditions:
  • enter
  • bypass
  • pan, where n = 1, 2, 3
  • pfn, where n is 1 to 24
  • pakey
  • pfkey
No special considerations.
VisualAge Generator sqlItem state conditions:

  • BLANK or BLANKS
  • NULL
  • NUMERIC
  • TRUNC
Corresponding EGL sqlItem state conditions:
  • blanks
  • null
  • numeric
  • trunc

The migration tool converts to the equivalent EGL state conditions.

Special considerations apply to sqlItem NULL. See Checking SQL and map items for NULL for details and potential problems.

VisualAge Generator record state conditions:

  • DED
  • DUP
  • EOF
  • ERR
  • FMT
  • FNA
  • FNF
  • FUL
  • HRD
  • LOK
  • NRF
  • UNQ
Note:
  • DUP is supported for both SQL and non-SQL records.
  • For SQL records, DUP and UNQ are equivalent and are always hard errors.
  • For non-SQL records, DUP and UNQ are not equivalent; both are soft errors.
  • LOK is only supported on OS/400 and is a soft error.
Corresponding EGL record state conditions:
  • deadLock
  • duplicate or unique
  • endOfFile
  • ioError
  • invalidFormat
  • fileNotAvailable
  • fileNotFound
  • full
  • hardIOError
  • deadLock
  • noRecordFound
  • unique
Note:
  • duplicate is only supported for non-SQL records and is a soft error.
  • unique is a hard error for both SQL and non-SQL records.
  • LOK is converted to deadLock, which is always a hard error.

The migration tool converts to the equivalent EGL state conditions.

Special considerations apply to migrating DUP based on the record type. See I/O error values UNQ and DUP for details and potential problems.

Special considerations also apply to migrating LOK. See I/O error value LOK for details and potential problems.

User Interface record state conditions:
  • MODIFIED
Corresponding EGL uiRecord conditions:
  • modified
This release of EGL does not support web transactions or UI records. However, testing the UI record state for MODIFIED is expected to be the same for both a map and a UI record. The migration tool converts a logical expression that tests for MODIFIED without regard to whether the part being tested is a map or a UI record. This preserves as much of your logic as possible.
VisualAge Generator dataItem state conditions:
  • BLANK or BLANKS
  • NUMERIC
Corresponding EGL dataItem state conditions:
  • blanks
  • numeric
No special considerations.
VisualAge Generator EZESYS state conditions:

  • AIX
  • AIXCICS
  • HP
  • IMSBMP
  • IMSVS
  • MVSBATCH
  • MVSCICS
  • NTCICS
  • OS2
  • OS2CICS
  • OS2GUI
  • OS400
  • SCO
  • SOLACICS
  • SOLARIS
  • TSO
  • VMCMS
  • VMBATCH
  • VSEBATCH
  • VSECICS
  • WINGUI
  • WINNT
  • ITF
Corresponding sysVar.systemType state conditions:
  • aix
  • AIXCICS
  • hp
  • imsbmp
  • imsvs
  • zosbatch
  • zoscics
  • NTCICS
  • OS2
  • OS2CICS
  • OS2GUI
  • iseriesc
  • SCO
  • SOLACICS
  • solaris
  • TSO
  • VMCMS
  • VMBATCH
  • VSEBATCH
  • VSECICS
  • WINGUI
  • win
  • debug

The migration tool converts to the equivalent EGL state conditions.

Special considerations apply to checking the state for EZESYS. See EZESYS for details and potential problems.

Note:
Not all of the VAGen runtime environments are supported by this release. However, the migration tool always converts to an equivalent value, even if it will not be valid in EGL. There will be an error on the Tasks list if the old VAGen value is not currently supported.
true/falseStatement in flow:

  • functionName() (main only)
  • EZECLOS
Corresponding EGL replacements:
  • goto functionName ;
  • exit program;
No special considerations.
true/falseStatement in a function:

  • functionName (any function)
  • EZECLOS
  • EZEFLO
  • EZERTN
Corresponding EGL replacements:
  • functionName();
  • exit program;
  • exit stack;
  • return;
No special considerations.

Figure 102. Statements -- CALL

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
CALL programName argument
     [ { [,] argument} ] 
     [ (options ] ;
 
 
OR
CALL serviceRoutine argument
     [ { [,] argument} ]
     [ (options ] ;
Note:
Commas to separate the arguments are optional.
call programName argument 
     [ { , argument } ] 
     [ options ]  ;
Note:
  • Commas to separate the arguments are required.
  • The programName cannot be a reserved word. If the program is a non-EGL program, use a linkage table entry to specify the real name.

See later rows in this table for conversion of the options to the corresponding EGL statements or options.

See Service Routines for information on migrating the CALL statement for them.

REPLY option If the REPLY option is specified in VisualAge Generator, the corresponding EGL statements are as follows:
try
  call programName argument
       [ { , argument } ]
     [ otherOptions ]  ;
end
The migration tool includes the try...end block if the REPLY option is specified.
otherOptions:
  • NOMAPS
  • NONCSP
Corresponding EGL otherOptions:
  • noRefresh
  • externallyDefined
No special considerations.

Figure 103. Statements -- DXFR

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
DXFR target 
     [ recordName ] 
     [ (NONCSP ] ;
 
 
where target is
programName
 
OR
EZEAPP
Note:
  • Any record can be passed.
  • If a working storage record is passed, any level 77 items are not included.
transfer to program target 
   [ passing  recordName ]
   [ externallyDefined ] ;
 
 
where target is
programName
 
OR
sysVar.transferName
Note:
Any record can be passed.
No special considerations.

Figure 104. Statements -- XFER

VisualAge Generator 4.5
EGL produced by the migration tool Migration tool considerations
Variation 1 - Migrate to Transfer (no map or UI record)
XFER target 
     [ recordName ]
     [ (NONCSP] ;
 
 
where target is
transactionName
 
OR
EZEAPP
Note:
  • This format of XFER does not include a map or UI record.
  • Any record can be passed. If a working storage record is passed, any level 77 items are not included.
  • transactionName is the programName in nontransactional runtime environments.
EGL syntax for transfer statement:
transfer to transaction target 
   [  passing  recordName ]
   [ externallyDefined ] ;
 
 
where target is
transactionName
 
OR
sysVar.transferName
Note:
  • Any record can be passed.
  • transactionName is the program name in nontransactional runtime environments.
If there is no comma in the statement, the migration tool converts the XFER to an EGL transfer to transaction statement.
Variation 2 - Migrate to Show (XFER with map)
XFER target 
     [ recordName ]
     , map
     [ (NONCSP ] ;
 
 
where target is
transactionName
 
OR
EZEAPP
Note:
  • Any record can be passed. If a working storage record is passed, any level 77 items are not included.
  • transactionName is the programName in nontransactional target environments.
EGL syntax for show statement:
show formName
  returning to target
  [ passing recordName ]
  [ externallyDefined ] ;
 
 
where target is
transactionName
 
OR
sysVar.transferName
 
Note:
  • Any record can be passed.
  • transactionName is the programName in nontransactional target environments.

The migration tool distinguishes between Variation 2 (XFER with a map) and Variation 3 (XFER with a UI record) as follows:

  • Use Variation 2 (XFER with a map) if any of the following are true:
    • (NONCSP is specified.
    • The second argument is a map.
  • Use Variation 3 (XFER with a UI record), if any of the following are true:
    • The target is ' '.
    • The name of the second argument is longer than 8 characters.
    • The second argument is a UI record.
  • If the migration tool is unable to determine if the second argument is a map or UI record, the tool uses variation 3.

Special considerations apply if the migration tool cannot distinguish between a map and a UI record. See XFER for details and potential problems.

Variation 3 - Migrate to Show (XFER with UI Record)
XFER target  [ record ]
     , UIRecord
 
 
 
where target is
transactionName
 
OR
EZEAPP
 
OR
' '
Note:
  • Any record can be passed. If a working storage record is passed, any level 77 items are not included.
  • transactionName is the programName in nontransactional target environments.
EGL syntax for forward statement:
forward UIRecord
  [ returning to target ]
  [ passing recordName ]  ;
where target is
transactionName
 
OR
sysVar.transferName
 
OR
UI record
Note:
  • Any record can be passed.
  • transactionName is the programName in nontransactional target environments.

This release of EGL does not support web transactions, UI records, or a replacement for XFER with a UI record. However, the forward statement is expected to be the replacement for XFER with a UI record. The EGL syntax might not be correct. However, using this migration technique preserves as much of your logic as possible. The migration tool distinguishes between Variation 2 (XFER with a map) and Variation 3 (XFER with a UI record) as follows:

  • Use Variation 2 (XFER with a map) if any of the following are true:
    • (NONCSP is specified.
    • The second argument is a map.
  • Use Variation 3 (XFER with a UI record), if any of the following are true:
    • The target is ' '.
    • The name of the second argument is longer than 8 characters.
    • The second argument is a UI record.
  • If the migration tool is unable to determine if the second argument is a map or UI record, the tool uses variation 3.

Special considerations apply if the migration tool cannot distinguish between a map and a UI record. See XFER for details and potential problems.


[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]