ALP Programming Guide and Reference/Assembler Messages

This section describes all the messages produced by ALP at run time. Messages issued by the assembler have the following format:

[Coordinates] [Severity Type] [Message Number] [Message Content]

The following sections describe the various fields common to all assembler messages, and a complete description of each individual message is included.

Message Coordinates

Message coordinates (if present) appear as the first field within a message, and have one of two forms:

[Path]Filename(LLLL:CCCC):

[Path]Filename(LLLL,Macroname(LLLL,CCCC)):

Coordinates are displayed as part of a message if ALP is parsing an input stream and the event which caused the message to be diplayed is directly related to a specific location in the input. The coordinates show the user exactly where to look if action is required. The fact the ALP is parsing an input stream does not mean that coordinates will appear in a message; some messages may occur during parsing that are not a reference to the input stream.

Filename

This is the name of the file containing the input token which caused the message to be generated. If this is the root source file whose name was passed on the assembler command line, the file name will be displayed exactly as specified by the user. If this is an INCLUDE file, it will be displayed exactly as specified in the INCLUDE directive, and the path name where the file was searched for and found (if any) will be prepended to the beginning. ALP does not query the operating system in an attempt to derive the full path name of a partially qualified file.

Macroname

If the assembler is currently parsing tokens within a macro expansion, the name of the macro currently being expanded will appear in the coordinates.

Line Number (LLLL)

The first number in parentheses is the line number within the source file where the referenced token is located; this refers to the outer-most point of invocation if a macro name is also given in the message coordinates. A line number value appearing within parentheses following a macro name refers to the innermost point of expansion (since macro expansions may be nested) and references the original definition of the macro.

Column Number (CCCC)

The second number in parentheses is the column number of the first character of the referenced token within the source file or macro definition.

Message Severity Types

Every message displayed by ALP is assigned a specific type, and the type of message dictates the severity level. The following is a list of message types produced by ALP showing the type name (as it appears in the actual message), followed by a description of what caused the message, how severe it is, and the action taken by ALP after the message is generated.

Info: Informational message only; processing continues normally.
Warning: Questionable syntax or semantics; input file may be incorrect, but processing continues.
Error: Syntax or semantic error in input; continue processing, object output file is discarded.
Fatal: Unrecoverable user or environment error; terminate assembly prematurely after releasing resources and closing files.
Internal: Internal program logic error, abort immediately.
Usage: Incorrect command line syntax, abort.

When the assembler begins processing, the display of all warning messages is enabled; informational messages do not display unless they are requested . The display of both warning and informational messages may be controlled with the command line option M - Control Individual Messages or Groups See Message Control Options for more information on the behavior of assembler messages.

Message Numbers and Message Content

Messages numbers displayed by ALP have the following format:

ALPnnnn:

Message numbers always have a three-letter prefix that designates the component issuing the message (ALP), followed by a four digit decimal number given by nnnn. All messages issued by the assembler are uniquely numbered; however, not all messages displayed by the assembler will be accompanied by a formatted message number (for instance, the assembler banner).

Messages issued during assembler initialization, command line processing, or exception handling are numbered from 0 to 999. Other messages occur during input stream processing and are grouped according to their severity type: 1000 through 1999 for fatal errors, 3000 through 3999 for regular errors, 4000 through 4999 for warnings, and 5000 through 5999 for informational messages.

It should be noted that messages are numbered for reference only; it is not guaranteed that messages will be numbered identically for each subsequent assembler release, or that individual messages will be retained or remain unmodified in future releases.

Message Numbers 0-999: Internal, Usage, and Special Case Messages

Messages in this section normally occur during assembler initialization, when errors are encountered during command line processing, or when exceptional conditions occur that prevent the assembler from completing initialization or execution.

ALP0004: <signal> received, <assembler-name> is shutting down: ALP has handled a request from the operating system to abort execution. The type of abort request is noted in the text of the message. All open files will be closed and any incomplete output files will be deleted.; Recovery: If termination was requested by the user, no further action is necessary. Otherwise, the operating system may have sent an abort signal because of insufficient system resources.
ALP0005: Assertion failure, <reason>: This message is displayed when an internal self-check condition has been violated, and indicates an error in the internal programming logic of the assembler. This message should never occur.; Recovery: Note the conditions under which the error occurred, and if possible isolate a minimal test case that will reproduce the problem. Contact IBM.

ALP0942: -Lo:xxxxxxxxxxxx must be one each of "XYZLMICFOGDS": This option specifies the sort order for the individual vertical listing file columns. Not all single character tags that uniquely identify each individual column were specified.; Recovery: All column tags must be specified in the argument field of this option, even when the display of one or more columns has been disabled.

ALP0981: Invalid or missing include path: The list of INCLUDE file directories was incorrectly specified.

ALP0991: Invalid option "<option>": The command line parser encountered a character sequence on the command line that was interpreted as an option, but the option identifier itself was not recognized.

ALP0992: Option "<option>" not valid in global scope: An attempt was made to use an option in a situation that would cause ambiguities. As coded by the user, the option is only legal when applied to an individual filename.; Recovery: If the option syntax is correct, insure that it follows the filename to which it applies.
ALP0993: Option "<option>" not valid in local scope: An attempt was made to apply a global assembler option to an individual file.; Recovery: Global options must appear before any filenames; in most cases the usage of global options and filenames is a mutually exclusive operation.
ALP0994: Invalid argument in option "<option>": In the argument field of a parameterized command line option, an argument of a specific type was expected, but an invalid token was encountered instead.
ALP0995: Expecting ":" or "=" in option "<option>": A parameterized option was encountered, but no colon (:) or equal sign (=) followed the option identifier.; Recovery: Parameterized options must be immediately followed by a colon or equal sign with no intervening white space characters, followed by the option argument(s).
ALP0996: Invalid message number: An explicit message number specified with the -M option did not identify a message for which switching is enabled.; Recovery: Only warning and informational messages may switched on or off.
ALP0997: Invalid keyword "<keyword>" in option "<option>": The referenced identifier was not a valid keyword; a keyword was expected in the context of the referenced option.

Message Numbers 1000-1999: Fatal Error Messages

Fatal errors typically occur when the assembler requests a resource from the operating system, but the request fails. This may or may not be due to user error, but the assembler was unable to correct the problem and execution is terminated after an orderly shutdown is performed.

ALP1101: Memory allocation error

The assembler attempted to dynamically allocate a block of storage, but the request was denied.

Recovery:

Close any large or memory intensive processes
Verify that sufficient paging space exists
The host computer may have insufficient hardware resources

ALP1102: Too many error messages

This message is displayed when the assembler has reached the error limit threshold.

Related Information:

Me - Set Number of Errors Before Assembler Aborts

ALP1103: Error opening message output file "<file>"; <reason>

An error occurred while attempting to open the referenced file.

Recovery: Verify that the file exists and that read permission is allowed. Verify that no other processes are accessing the file, and that the file system is functioning correctly.

ALP1104: Input and message output filenames are identical

The assembler has detected an attempt to create an output file with a name identical to that of an input file; the operation was not allowed.

The assembler only detects this condition when the names are an identical match , using a case-sensitive comparison algorithm.

Recovery: Ensure that the correct command line options have been used. Internal variables may have been incorrectly initialized using options that affect automatic file name generation, thus causing a filename collision.

Related Information:

Internal Variables
File Control Options

ALP1401: Error opening listing output file "<file>"; <reason>

An error occurred while attempting to open the referenced file.

Recovery: Verify that the file exists and that read permission is allowed. Verify that no other processes are accessing the file, and that the file system is functioning correctly.

ALP1402: Error writing listing output file "<file>"; <reason>

An error occurred while attempting to write to the referenced file.

Recovery: Ensure that there is sufficient space on the target file system, and no other processes are accessing or modifying the file. Verify that the file system is functioning correctly.

ALP1403: Input and listing output filenames are identical

The assembler has detected an attempt to create an output file with a name identical to that of an input file; the operation was not allowed. The assembler only detects this condition when the names are an identical match , using a case-sensitive comparison algorithm.

Recovery: Ensure that the correct command line options have been used. Internal variables may have been incorrectly initialized using options that affect automatic file name generation, thus causing a filename collision.

Related Information:

Internal Variables
File Control Options

ALP1601: Error creating object output file "<file>"; <reason>: An error occurred while attempting to create the referenced file.; Recovery: Verify that the target drive and directory exist and that create and write permission have been granted. Verify that no other processes are accessing the file, and that the file system is functioning correctly.
ALP1602: Error writing object output file "<file>"; <reason>: An error occurred while attempting to write to the referenced file.

Recovery: Ensure that there is sufficient space on the target file system, and no other processes are accessing or modifying the file. Verify that the file system is functioning correctly.

ALP1603: Input and object output filenames are identical: The assembler has detected an attempt to create an output file with a name identical to that of an input file; the operation was not allowed. The assembler only detects this condition when the names are an identical match , using a case-sensitive comparison algorithm.; Recovery: Ensure that the correct command line options have been used. Internal variables may have been incorrectly initialized using options that affect automatic file name generation, thus causing a filename collision.

Related Information:

Internal Variables
File Control Options

ALP1801: Error opening source file "<file>"; <reason>: An error occurred while attempting to open the referenced file.; Recovery: Verify that the file exists and that read permission is allowed. Verify that no other processes are accessing the file, and that the file system is functioning correctly.
ALP1802: Error reading source file "<file>"; <reason>: An error occurred while attempting to read from the referenced file.; Recovery: Ensure that the file exists, that the filelength is non-zero, and that read permission is allowed. Verify that no other processes are accessing the file, and that the file system is functioning correctly.
ALP1803: Circular text substitution: The preprocessor has detected an attempt to perform a recursive text substitution operation, such as an INCLUDE file "including" itself, or a macro expanding itself.
ALP1804: Internal buffer overflow: The preprocessor has overflowed an internal memory buffer while trying to process the referenced token.; Recovery: Reduce the number of whitespace characters preceding the token or the number of characters in the token itself.

ALP1901: Unexpected character <character-value> in identifier: The command line parser was expecting an identifier but immediately encountered a non-identifier character. Command line parsing was prematurely terminated.
ALP1902: Unexpected character <character-value> in keyword: The command line parser was expecting an keyword but immediately encountered a non-identifier character. Command line parsing was prematurely terminated.
ALP1903: Error opening response file "<file>"; <reason>: An error occurred while attempting to open the referenced file.; Recovery: Verify that the file exists and that read permission is allowed. Verify that no other processes are accessing the file, and that the file system is functioning correctly.
ALP1904: Invalid filename in "@" directive: The command line parser was processing an @Filename (command line response file) directive, but the token following the "@" character did not constitute a valid filename.; Recovery: Ensure that only valid filename characters are used.
ALP1905: Unexpected character or terminator <character-value>: The command line parser encountered either an illegal control character or the end of the command line input stream before the current command parameter was completely parsed.
ALP1906: Numeric constant is invalid; <reason>: An error occurred while converting the referenced numeric constant to an internal representation.

Message Numbers 3000-3999: Error Messages

Error messages are typically issued during processing of the input stream and indicate a syntax or semantic error in the user program. The assembler will continue processing after an error has occurred, but since the input stream was incorrect an output object file will not be created.

ALP3201: Can't <verb> <expr_type> <from/to/by/with> <expr_type>: This message appears during expression processing when a binary operation was performed on two primary expressions of incompatible type. The message replacement parameters indicate the attempted operation.
ALP3202: Overflow or division by zero: Either the expression evaluated to a quantity that is not representable in the current expression word size, or an expression contained a binary division (/) or modulus (MOD) operation where the denominator expression was evaluated to be zero.
ALP3203: Can't take offset of expression: The expression to which the OFFSET operator was applied did not contain a constant or relocatable address.; Recovery: The offset operator may not be applied to register values. If the offset expression is applied to a quoted string, ensure that the string length does not exceed the length of what is representable as a constant value, given the word size of the enclosing segment (2 for USE16 segments, 4 for USE32 segments).
ALP3204: Expecting relocatable expression: An expression was used in a context that required a segment or group relative address, but one was not supplied.
ALP3205: Expecting primary expression: The assembler was expecting a terminal operand (an identifier, register, or constant) or an expression enclosed in parentheses () or square brackets [ ]; instead, an unexpected token was encountered at the referenced location.
ALP3206: Expecting "]": An opening bracket "[" was encountered and the subsequent expression was fully parsed, but a closing bracket "]" was not encountered.
ALP3207: Expecting ")": An opening parenthesis "(" was encountered and the subsequent expression was fully parsed, but a closing parenthesis ")" was not encountered.
ALP3208: Forward reference needs segment override or FAR PTR: An expression contained a forward reference to a location that was later determined to be of FAR distance. When forward references are used, the assembler makes default assumptions about the eventual definition of undefined labels used in the expression; such definitions are never assumed to be in a different segment. Use of such an expression can cause differences between the code generated on the first and second passes of the assembler.; Recovery: Qualify the expression with a distance override (FAR, FAR16, or FAR32) or segment override (:) operator.

ALP3210: Illegal operation on relocatable value: A unary operator was applied to an expression containing a relocatable address or indirect memory expression, but the operator may only be used with constant values.
ALP3211: Illegal type expression: A "<type> PTR" type conversion expression was encountered, but the expression given by <type> was not a valid qualified type.
ALP3212: Operands must be relative to same segment or group: A binary operation was performed on two relocatable expressions, but the expressions were not declared relative to the same segment.
ALP3213: Illegal digit(s) for current .RADIX: A literal integer constant was not qualified with a prefix or suffix (radix override), but was specified using digits that are not valid for the current radix. For instance, use of the literal 1234 is illegal when the current radix value is 2.
ALP3214: Value cannot be negative: A negative-value expression was encountered where only positive numbers are allowed, such as the count-value for the DUP operator, the field-width entry in a RECORD definition, or the shift-value in the SHL or SHR operators.
ALP3215: Expression cannot be forward-referenced: The referenced expression is used in a context where an undefined or forward-referenced value prevents the assembler from completing the operation or generating a reliable construct. This is the case during the declaration of user-defined types or where the value of the location counter will depend on the results of the expression.
ALP3216: Expression does not have an operand size: The SIZE operator was used on an expression for which no operand size exists (a simple number value, for example). The SIZE operator may only be used on expressions that have an operand size attribute, such as a variable name or type name expression.
ALP3217: Record tag expected: A left-hand identifier operand was followed by a right-hand expression list operand enclosed in angle brackets or braces. The construct was parsed as a record constant, but could not be evaluated because the left-hand operand was not a record tag name previously defined with the RECORD directive.
ALP3218: Numeric constant is invalid; <reason>: An error occurred while converting the referenced numeric constant to an internal representation.
ALP3219: Expression must be a constant value: The assembler issues this message whenever a constant expression is required, but the expression supplied contained relocation information or machine register references.

ALP3220: Undefined symbol "<identifier>": This message appears when an identifier was referenced in an expression or type declaration, and the identifier has no external declaration or definition or is forward-referenced.
ALP3221: Expecting "," or ")": This message appears when processing a DUP expression list and an unexpected token was encountered. The parser was expecting the list to be continued with a comma or terminated with a closing parentheses.

Recovery: Check for possible unbalanced parentheses ().

ALP3222: Expecting "(": The DUP operator was encountered but was not followed by an opening parentheses to begin the duplicated expression list.; Recovery: The duplicated expression list following the DUP operator must be enclosed in parentheses (), even if the expression list only contains a single item.
ALP3223: Expecting variable name: The LENGTH operator may only be applied to data labels (variable names). LENGTH returns the number of items allocated to the data label when the label was defined in a data allocation statement.
ALP3224: Expecting "," or "<closing brace/bracket>": This message appears within a bracketed expression list where the assembler was expecting a comma to introduce the next initializer expression, or a closing brace or angle bracket to terminate the initializer expression list.
ALP3225: Register-indirect expression illegal in this context: A constant or relocatable address expression was expected but the expression also contained at least one machine register. Such an address may be calculated only at run time, and is illegal in this context.
ALP3226: Expression must have structure or union type: The expression to the left of a structure member selection operator (.) did not have a structure or union type. The assembler cannot evaluate the member expression to the right of the selection operator unless the left hand operand has an associated structure or union type.; Recovery: If the left hand operand must be something other than an explicit structure or union variable (such as a register-indirect expression like [EBX]), then use the PTR operator to convert the left hand operand to the appropriate type.
ALP3227: Right operand is not a member of structure or union: The expression to the right of a structure member selection operator (.) was not a member of the left-hand structure or union expression.; Recovery: The right-hand operand must be an identifier named in the type definition for the structure or union.
ALP3228: Invalid identifier type for this operation: The symbol type of the referenced identifier was not valid in this context.

Recovery: This could happen if a text macro name was used in a context where macro expansions are not performed.

ALP3229: Expression type not valid in this context: The referenced expression evaluated to a type that is not valid for the context in which it was used. An example of this would be the use of a segment name or group name where a data label was expected.; Recovery: Review the expression-types allowed by the statement or clause where the referenced expression was used, and modify the construct accordingly.

ALP3301: Label must be followed by a directive: A user identifier appeared in the label field, but the end of line was encountered before an assembler directive was specified to give the label a definition.; Recovery: Code labels must be followed by a single colon (:) or double colon (::) on the same line as the label itself. Named assembler directives must appear on the same line as the associated label, or the line continuation (\) character must follow the label to create a single logical line.; Check for a possible misspelled identifier or keyword. Verify that the identifier was specified using the correct uppercase and lowercase letters if case sensitive assembly is in effect.
ALP3302: Expecting label, directive, or mnemonic: The token referenced in the error message was unexpected. This error occurs when the first token on the line is not a valid label, directive, or mnemonic, or when a valid label has been encountered but was not followed by a valid directive or mnemonic.; Recovery: If this message references an identifier, check that it was spelled correctly, or that the identifier was specified using the correct uppercase and lowercase letters if case sensitive assembly is in effect.
ALP3303: Can't be preceded by data label: The referenced token is either an instruction mnemonic or a user identifier that appears after a label.; If the referenced token is an instruction mnemonic, then the preceding label must be followed by a single colon (:) or double colon (::). Data labels may not be used to refer to instructions. Otherwise, it is invalid to have two labels appearing in succession.; Recovery: Check for misspellings in either identifier, and that the identifiers were specified using the correct uppercase and lowercase letters if case sensitive assembly is in effect.

ALP3501: Address size mismatch

This message indicates one of the following:

An indirect memory expression contained a mixtre of 16-bit or 32-bit base or index registers. This prevents the assembler from determining the address size of the expresson, and is illegal.
The instruction performs an unalterable implicit operation which conflicts with the operands supplied.

ALP3502: Invalid register expression

A processor register was specified using indexed notation (i.e., "REG(X)"), but the expression in parentheses was out of range and did not refer to a valid register.

ALP3503: Can't use this register with scale factor

In an indirect memory expression, the scaling operator (*) was applied to a register for which the processor does not support a scaling operation.

A scaling factor may only be used on 80386 or later processors, and only in 32-bit address expressions. Within this context, only the EAX, EBX, ECX, EDX, EDI, ESI, and EBP registers are valid. A scaling factor may not be applied to the ESP register.

ALP3504: Illegal target of self relative pointer

The SHORT operator was used, but the expression to which it was applied was not a simple self relative displacement. This can occur if the expression is a constant, data label, or indirect memory operand.

ALP3505: Invalid mnemonic/operand combination

This message appears when a valid mnemonic has been recognized and all operand expressions have been correctly parsed, but the assembler was unable to combine the results into a form that it could associate with a valid instruction encoding.

Recovery: This usually indicates that one or more operand expressions were not correctly specified. Verify such factors as:

Correctly specified operand sizes
Register combinations allowable for this instruction
Labels or identifiers are of the correct type
Correct number of operands

ALP3506: Register combination invalid with <number>-bit expression

For 80386 processors or greater, both 16-bit and 32-bit effective addresses are supported, but the two modes differ in the register combinations that are allowed for indirect addressing. The expression used a combination that was invalid for the referenced address size.

For expressions that refer to 16-bit (USE16) memory locations, only a single base register (BX or BP) and/or a single index register (DI or SI) may be used.

For expressions that refer to 32-bit (USE32) memory locations, only a single base register (EAX, EBX, ECX, EDX, ESP, EBP, EDI, ESI) and/or a single index register (EAX, EBX, ECX, EDX, EBP, EDI, ESI) may be used; no single register may appear more than once in a given expression.

ALP3507: Scaling factor must be 1, 2, 4, or 8

The processor only supports the scaling factors referenced in the message.

ALP3508: Invalid use of register

One of the following illegal conditions occurred:

An attempt was made to use an unsupported register in an indirect memory expression (for example, [AH]).
An attempt was made to combine a register with other terms to form an indirect memory expression, and the register was not enclosed in square brackets [ ].
A register argument was expected and correctly parsed in an assembler directive, but the referenced register cannot be legally used in this particular context.

ALP3509: Multiple base registers: An indirect memory expression contained a combination of registers that was invalid for the selected addressing mode. More than one register was evaluated as a base register by the assembler; the processor only supports a single base register within register indirect addressing mode.; For expressions that refer to 16-bit (USE16) memory locations, only BX and BP are valid base registers.; For expressions that refer to 32-bit (USE32) memory locations, only EAX, EBX, ECX, EDX, ESP, EBP, EDI, and ESI are valid base registers.

ALP3510: Multiple index registers: An indirect memory expression contained a combination of registers that was invalid for the selected addressing mode. More than one register was evaluated as an index register by the assembler; the processor only supports a single index register within register indirect addressing mode.; For expressions that refer to 16-bit (USE16) memory locations, only DI and SI are valid index registers.; For expressions that refer to 32-bit (USE32) memory locations, only EAX, EBX, ECX, EDX, EBP, EDI, and ESI are valid index registers.
ALP3511: Multiple scaling factors: In an indirect memory expression, the scaling operator (*) was applied to more than one register term. The processor does not support more that one scaling factor within a single effective address.
ALP3512: Near target cannot be in different code segment: A JMP or CALL instruction specified a near target that was defined in a different segment, but the segments containing the instruction and the target were not named together in a GROUP directive. An instruction and its near target cannot be in different segments (addressed by the CS register) at run time.; Recovery: If the instruction was otherwise properly coded, use the GROUP directive to collect the segments together so that they will be accessible at run time with the same CS register value.
ALP3513: Need size for operand: The instruction operand list did not specify a size for the operation, and the assembler is unable to select a default instruction encoding because multiple variations exist.; Recovery: As size may be assigned to one or more of the operands by using the <type> PTR override operator.
ALP3514: Cannot establish near target without ASSUME CS:: When running the under MASM 5.10 emulation, the assembler requires the code segment register (CS) to have an ASSUME setting for the currently opened segment before it will allow the creation of explicit near code labels.; Recovery: Insert an "ASSUME CS:SegName" statement at the beginning of the segment before the appearance of any near code labels.
ALP3515: Code generation outside of segment boundaries: A processor instruction was encountered, but no program segment has been opened.; Recovery: Place all processor instructions within a named program segment.
ALP3516: Target is out of range by <displacement> bytes(s): The instruction references a code label or address using a self-relative displacement (a signed value relative to the address of the next instruction), but the target address requires a displacement value that is too large to be encoded into the instruction.; Recovery: If the SHORT operator was used in the operand field, remove it. If the instruction is of the "conditional jump" variety, it may be necessary to transform it into a "jump around a jump" by inverting the condition under which the jump is performed, then changing the target so that it references an address immediately following a "direct jump" instruction, which must be inserted and coded so that it references the original target location.
ALP3517: Selected processor does not support this operand: An attempt was made to use an operand (such as a machine register) that does not exist on the processor for which code is being generated.; Recovery: Either use a processor selection directive to select the correct target processor, or modify the referenced operand to one that is supported on the target machine.
ALP3518: Can't access data, no ASSUME or segment override: One of the following conditions occurred:

An attempt was made to reference a named memory location that exists in a segment for which no ASSUME statement is in effect
An attempt was made to combine two terms in a binary expression that are relative to different segments.

ALP3519: Too many operands: This message appears during processing of an instruction operand list. More operand expressions were encountered than is valid for the instruction set of the target architecture.; Recovery: Remove the offending token(s) beginning at the referenced location.

ALP3520: Segment address size not supported on this processor: A 16-bit processor selection directive was encountered within a 32-bit segment, or an attempt was made to reopen a 32-bit segment after switching to a 16-bit processor type. The selected processor cannot support 32-bit segments.
ALP3521: Register expected: While processing an assembler directive an unexpected token was encountered at the referenced location. A processor register was expected instead.
ALP3522: Selected processor does not support this instruction: A mnemonic or mnemonic/operand combination has been used that is not supported by the processor for which the assembler is currently generating object code.; Recovery: Verify that the correct target processor has been selected with one of the processor selection directives, or that the correct instruction form has been coded. Since ALP does not perform some of the same implicit conversions that MASM 5.10 does, use of the <type> PTR conversion operator may be required to avoid certain type-mismatch problems.
ALP3523: Cannot change expression word size: After the expression word size was explicitly set with an OPTION EXPRxx directive, an attempt was made to alter the setting with another OPTION directive, or by switching to a 32-bit processor after an explicit OPTION EXPR16 was issued. Once set, the expression word size cannot be altered.

ALP3601: Filename expected: The INCLUDELIB directive was used, but an error occurred while attempting to parse the filename parameter.; Recovery: Verify that only legal filename characters are used. If the filename appears as a quoted string literal, verify that the literal uses legal syntax according to the rules for quoted strings.
ALP3602: Floating-point initializer illegal with integer variable: A floating point initializer was used on a variable that was not of type DD, DQ, DT, REAL4, REAL8, or REAL10.
ALP3603: Integer initializer illegal with floating-point variable: An integer initializer was used on a variable that was of type REAL4, REAL8, or REAL10. Only floating-point initializers can be used with variables having these types.
ALP3604: Expression has no effect: During a data allocation directive, an attempt was made to initialize an item using an expression that was not correctly evaluated.; Recovery: This may indicate an error in the internal assembler logic. Note the conditions of the error, and contact IBM.
ALP3605: String is empty: During a data allocation directive, an attempt was made to initialize an item using a quoted string expression that contained no data.; Recovery: Quoted strings must contain at least one character value, otherwise the expression is illegal.
ALP3606: Symbol "<identifier> was never defined: An identifier was declared with a GROUP or PUBLIC directive, but was never given a full definition. This condition prevents the assembler from writing the appropriate records to the output object file.; Recovery: Segments declared in a GROUP directive must defined in a SEGMENT directive. Identifiers declared with the PUBLIC directive must be defined as a code label, data label, or absolute symbolic constant.
ALP3607: Value not addressable: The expression following the END directive did not evaluate to segment relative address. The expression must refer to a memory location to which the operating system loader can pass control when the program is executed.; Recovery: Ensure that the expression contains no machine registers, and that it references a value relative to a segment defined within the module.
ALP3608: Segment size exceeds 64K limit: The amount of data emitted into the current (16-bit) segment has exceeded 65536. No object file can be produced under this condition, and the current location counter has been wrapped back to zero.; Recovery: Reduce the amount of code or data contained in this segment, or move some of the information to another segment.

ALP3701: Argument expected: While processing a directive that accepts a list of comma separated arguments, at least one argument followed by a comma was parsed, but no additional argument was encountered before the end of the line.
ALP3702: Can't override array with single item: Within a structure variable instantiation, an incorrect attempt was made to override the default initializer of a structure member. The structure member was defined to be of type array (having been initialized with a character string or list of expressions enclosed in brackets), and the overriding expression in the structure instantiation was a single numeric expression.; Recovery: Array members can only be overridden using a quoted character string or a bracketed list of numeric expressions.
ALP3703: .RADIX value must be one of: 2, 8, 10, or 16: Self-explanatory.
ALP3704: Can't nest initializers: This message appears when a structure instantiation contained a nested override initializer within brackets, and OPTION OLDSTRUCTS was in effect. Nested structures are not allowed when the assembler is operating in this mode.
ALP3705: Colon expected: Self-explanatory.
ALP3706: Expecting "<" or "{": When a structure or record variable is allocated, the assembler expects one or more initializer expressions to follow the structure or record type name. Initializer expressions must be enclosed in angle brackets or braces, but an unexpected token was encountered at the referenced location.
ALP3707: Initializer too long or incorrect type: Within the initializer list of a structure instantiation, one of the following conditions occurred:

An attempt was made to initialize a structure member with a character string override that exceeded the length of the member definition.
The initializer expression type did not match that of the structure member item being initialized.

ALP3708: Invalid ALIGN setting: A zero or incorrect value was specified as the argument to the ALIGN directive.
ALP3709: Previous definition prevents external attribute: An attempt was made to declare an identifier as being external to this module, but a previous conflicting definition already exists. The operation is disallowed.

ALP3710: Syntax error; unexpected token: The referenced token is not valid for the construct being parsed. The assembler could not attempt further processing or diagnosis of the construct.
ALP3711: Previous definition prevents change in global visibility: One of the following conditions has occurred:

The PUBLIC directive or keyword was used to export an identifier, but the identifier has already been declared with attributes that prevent it from being exported.
A PUBLIC directive was used on a procedure name, but the PRIVATE keyword was used in the PROC directive that defined the procedure.

Recovery: Verify that the identifier does not appear in a COMM or EXTERN declaration, and that the identifier is a valid code or data label. Insure that the PUBLIC declaration appears before the identifier it references, and that the declaration is processed by the assembler on the first pass.

ALP3712: "<token>" must be a segment name: This message appears during processing of the GROUP directive when one of the arguments was not a valid segment name.

Recovery: Only identifiers defined using the SEGMENT directive are valid arguments to the GROUP directive. If the message is referencing an identifier, verify that it is indeed the name of a valid segment. Verify that the identifier was specified using the correct uppercase and lowercase letters if case sensitive assembly is in effect.

ALP3713: Label outside of segment boundaries: This message appears when a label definition appears outside of any enclosing segment.

The label is an assembler alias for a segment relative machine address; such an address cannot be assigned to the label unless it appears inside of a program segment. This condition is an error, and must be corrected.

Recovery: Place the definition within a valid segment.

ALP3714: Directive must be named: This message appears when a directive was encountered but was not preceded by a label. A label is required for this directive.

Recovery: Precede the directive with a valid identifier.

ALP3715: Must specify all columns in .LIST ORDER: The .LIST ORDER directive did not specify a position for every possible column. All column names must appear in the list.

ALP3716: Listing control stack is empty: This message appears when the user issues a .LIST POP directive and there are no listing environment entries on the stack.

Recovery: A matching .LIST PUSH directive must be issued before .LIST POP may be used.

ALP3717: Processor mnemonic used as a label: This message is issued when a processor instruction mnemonic is used as an identifier. The severity of this message may be relaxed from Error to Warning in certain circumstances by using the +Sk command line switch.

Related Information:

#Sk - Control Use of Reserved Words as Labels

ALP3718: Misplaced ENDP; no open PROC: This error occurs when the ENDP (end procedure) directive was encountered, but there is no procedure currently open.

Recovery: The PROC directive must be used to open a procedure before the ENDP directive can be used.

ALP3719: No closing bracket: An opening bracket "[" was encountered within a directive or expression, but a matching close bracket "]" was never supplied, or was misplaced.

ALP3720: Data allocation outside of segment boundaries: A data definition directive was encountered, but no program segment has been opened.

Recovery: Place all data allocation directives within a named program segment.

ALP3721: Operation illegal within structure or union: An attempt was made to use a directive or construct that is illegal within the context of a structure definition.

Recovery: Processor instructions are not allowed in structure definitions, and only a subset of assembler directives are legal in this context.

ALP3722: Expression is not a segment or group: One of the following illegal conditions occurred:

A segment override expression (using the colon (:) operator) did not contain a valid segment register, segment name or group name expression on the left side of the colon operator.
An ASSUME directive contained an expression that did not evaluate to a valid segment or group name. The argument to the ASSUME directive specified a machine segment register, which may only be associated with a segment or group name.

Recovery: Verify the correct spelling of either the register argument or the segment name or group name expression.

ALP3723: ON or OFF expected: A listing control directive was encountered where the value of a flag is being manipulated; the ON or OFF keywords are the only values acceptable in this context.
ALP3724: ON, OFF, or BLANK expected: A listing control directive was encountered where the display or non-display of an individual column is being determined; the ON, OFF, or BLANK keywords are the only values acceptable in this context.
ALP3725: Phase error between passes: The address assigned to a label on pass one of the assembler had a different value on the second pass.

This usually indicates that a forward reference to a label was not fully qualified, and the eventual definition of the label was different than what was assumed by the assembler on the first pass. On the second pass, the assembler did not need to make any assumptions about the attributes of the symbol, but the resulting generation of object code caused a discrepancy in the value of the location counter.

Recovery: Use the listing control command line options to request a listing for both pass one and pass two of the assembler; use this listing to compare location counter values prior to the point where the phase error occurred. This will reveal the instruction that caused the location counter to become unsynchronized.

Related Information:

#Lp - Generate Listing on Specific Pass

ALP3726: Symbol already defined as different type: An identifier has been redeclared to have attributes that conflict with a previous declaration or definition.; Recovery: If this is an external declaration (using an EXTRN or COMM directive) referencing a data variable, ensure that the type specifier has been correctly respecified. Verify that the variable has not already been defined within this module.

External declarations for data labels or near code labels appearing within segment boundaries must not reappear within the boundaries of a different segment. Labels appearing outside of segment boundaries inherit the default address size (USE16 or USE32), and must not reappear within a segment having a conflicting address size. Far code labels may not be redeclared with conflicting address sizes.

ALP3727: PROC name mismatch: The ENDP directive was used to close the current procedure, but the name used in the ENDP directive did not match the name specified in the matching PROC directive.
ALP3728: Symbol redeclared relative to different segment: A data label or near code label appearing in an external declaration was redeclared in a different segment (or outside of segment boundaries) and conflicts with a previous declaration or definition.; Recovery: Data labels or near code labels appearing within segment boundaries must not reappear within the boundaries of a different segment. Labels appearing outside of segment boundaries inherit the default address size (USE16 or USE32), and must not reappear within a segment having a conflicting address size.
ALP3729: Attribute mismatch during reopen of segment: An existing segment was reopened using different or conflicting attributes.; Recovery: All identically named SEGMENT directives must be declared with the same attribute list.; If an address size attribute (USE16 or USE32) was not explicitly specified in the SEGMENT directive, verify that the default segment word size was not altered between segment declarations with a processor selection directive.
ALP3730: No segment, structure, or union opened as "<identifier>": The ENDS directive was used, but no segment, structure, or union was open ( or did not match the referenced name) and thus could not be terminated.; Recovery: If a name was given in the message, verify that it matches the name used in the associated SEGMENT, STRUC, or UNION directive. Verify that nested occurrences of SEGMENT, STRUC, or UNION are paired with a matching ENDS directive.

ALP3731: Identifier expected: A directive or expression operator was used such that an identifier was expected, but none was supplied.; Recovery: Check for a possible misspelled identifier; Verify that the identifier was specified using the correct uppercase and lowercase letters if case sensitive assembly is in effect. Verify that the identifier is not a reserved keyword.

ALP3732: Reserved symbol "<identifier>" cannot be created or modified: An invalid operation was performed on a reserved identifier. One of the following conditions occurred:

An attempt was made through an EQU (or =) directive to alter the value of a predefined identifier. Unless documented otherwise, this is an illegal operation.
The assembler attempted the deferred creation of a reserved symbol, but a user-defined identifier already exists with the same name and has conflicting attributes.

ALP3733: Symbol redefinition error: An attempt was made to redefine an identifier in a context where redefinitions are not allowed. Redefinitions are allowed only for text macros and assembler variables assigned using the equal (=) directive.
ALP3734: Too many initializers: A bracketed expression list within a structure instantiation or record constant contained too many comma-separated expressions. The number of initializer expressions exceeded the number of elements in the structure or record definition.
ALP3735: Qualified type or type keyword expected: This message appears when a type expression or a COMM, EXTRN, or LABEL directive was expecting a type keyword, but none was supplied.
ALP3736: Unexpected text in statement: An assembler directive was fully parsed and recognized, but invalid information was encountered at the referenced location.
ALP3737: <text>: This assembler issues this message to display user defined text when the ECHO or %OUT directives are encountered.
ALP3738: Symbol redefinition has different value: An attempt was made to redefine an EQU symbol to value which differs from a previous definition. EQU symbols may have multiple definitions only if they have identical constant values.
ALP3739: Directive illegal outside of segment boundaries: The referenced directive performs a segment-relative operation and may only be used inside of segment boundaries.

ALP3740: Alignment value must be a power of 2: The expression argument given in the ALIGN directive did not evaluate to a power of 2 (2, 4, 8, etc.).
ALP3741: Alignment value not valid with current segment alignment: The referenced alignment factor was less than the alignment factor specified in the SEGMENT declaration containing the ALIGN or EVEN statement. This condition is illegal because the assembler cannot guarantee that the linker will not invalidate the requested alignment when it exercises its right to position the entire segment according to the alignment factor given in the enclosing SEGMENT declaration.; Recovery: Respecify either the aligment factor or the SEGMENT delaration so that the segment alignment is greater than or equal to any alignment factor requested therein.
ALP3742: Redefinition has different number of fields: A RECORD type redefinition did not contain the same number of fields as a previous definition.
ALP3743: Redefinition has different value: A redefinition construct was encountered (such as a type definition directive) where the redefined value did not match that of a previous definition. Redefinitions are allowed for this particular construct, but they must restate the same value given in the original definition.
ALP3744: Too many bits in record definition: The referenced record definition exceeded the maximum allowable value of 32 bits.
ALP3745: Record tag or fieldname expected: The operand of the MASK or WIDTH operators must be an identifier defined with the RECORD directive. This identifier must be either the tag name of the record itself, or one of the field name entries defined within the body of the RECORD directive.
ALP3746: Value is out of range: The value of the referenced expression is not representable, requires too many significant bits to be stored, or lies outside the range of legal values for this context.
ALP3747: Mismatch of segment address sizes in group: A group was declared to contain segments of differing address sizes. A group may contain either USE16 or USE32 segments, but not a combination of both.
ALP3748: Segment already a member of group "<group-name>": An attempt was made to assign a segment to more than one parent group.
ALP3749: Directive requires use of .MODEL: A simplified segmentation operation was encountered but a .MODEL directive was never processed.

ALP3750: PROC must immediately precede LOCAL: A LOCAL assembler directive was encountered, and one of the following occurred:

The LOCAL directive was not enclosed within a PROC/ENDP procedure block.
The LOCAL directive was positioned within a procedure block, but other assembler directives or instructions were encountered between the PROC directive and the LOCAL directive.

ALP3751: Operand has incorrect size: The size given for an operand was incorrect, or did not match that of a destination or target operand where it is to be used.

ALP3752: Mismatch in <attribute> attribute

The value of an attribute specified in a redeclaration or redefinition did not match the value given in the original declaration or definition. The body of the message indicates the type of attribute that is mismatched, and the assembler follows this message with two 5704 informational messages showing the coordinates and values of the mismatched constructs.

ALP3753: Name collision caused by promotion from inner scope

During a definition of a structure (or union) type, a field identifier defined at the outer (current) scope had the same name as a field defined in a promoted inner scope (one created through the use of an unnamed imbedded structure). When a structure type is used to create an unnamed field within another structure type, all of the field names from the inner structure are "promoted", or made visible to the outer defining scope.

Recovery: One of the field identifier names must be altered to avoid the name collision. Alternatively, the unnamed imbedded structure may be given an explicit field name, in which case its own fields are no longer promoted, and fully-qualified references must be used to reach them from within expressions.

ALP3754: Cannot determine calling convention

A procedure was defined to accept arguments passed on the stack by a calling routine, but no language attribute was specified or assumed for the procedure. The language attribute determines the calling convention, which in turn defines the order that arguments are pushed onto the stack.

Recovery: Use one of the following constructs:

Specify an explicit language keyword in the body of the PROC directive.
Specify a .MODEL directive with a language keyword argument.
Specify an OPTION LANGUAGE directive.

ALP3801: Argument expected: When processing one of the EQU, IRP, IRPC, FOR, or FORC macro directives, the required argument immediately following the directive was missing or incorrectly specified.; Recovery: Modify the referenced token so that it is a valid argument for the directive. If this directive appears within a nested macro expansion, check to see that correct arguments were passed to outer level macros, or that outer level macro definitions are correct.
ALP3802: EXITM outside of macro: The EXITM keyword was encountered outside the context of a macro body.; Recovery: Verify that unexpected conditional assembly results are not affecting the block structure of the program. The EXITM keyword may not be used outside the scope of a macro body.
ALP3803: Comma expected: Self-explanatory. This message is displayed for any preprocessor directive that requires a comma where one was not supplied.
ALP3804: Extra data on line: This message appears any time the preprocessor has parsed a correctly formed preprocessor directive, but additional token(s) (other than comments were encountered before the end of line was reached.; Recovery: Remove the offending token(s) beginning at the referenced location.

,ALP3805: Filename expected:This message appears when an INCLUDE preprocessor directive did not contain a properly formed filename. The INCLUDE directive is ignored.

ALP3806: <text>: This is the message printed as part of a conditional error directive; if one of these directives is processed and the user has included text information to be printed, it will appear in the <text> field of the message. If no user text was specified, this parameter will be empty and the message will contain no additional text.; Recovery: This was a forced error.
ALP3807: Identifier expected: This message appears when a conditional preprocessor directive was expecting an identifier and one was not supplied.
ALP3808: Reserved macro "<macro-name>" cannot be redefined: The assembler defines the referenced identifier for its own purposes; it may not be redefined by the user.
ALP3809: Missing ENDM: The preprocessor was reading the body of a macro definition when the end of the current input stream was reached; the macro definition was never closed with an ENDM keyword.; Recovery: Verify that unexpected conditional assembly results are not affecting the block structure of the program. A macro definition may not be closed in an input stream different from the one where it was started.

ALP3810: <ELSExx/ENDIF> without matching IFxxx: This message indicates that an ELSE or ENDIF construct was encountered prior to encountering an IF construct.
ALP3811: Reserved symbol "<identifier>" cannot be modified: An attempt was made through the -D command line option to alter the value of a predefined identifier. Unless documented otherwise, this is an illegal operation.
ALP3812: Symbol "<identifier>" already defined: An attempt was made to define a preprocessor macro name that conflicts with an existing identifier of an incompatible type.
ALP3813: <Text-Item> expected: This message is displayed when a preprocessor directive expected a text argument enclosed in angle brackets < >, but a valid argument was not supplied.
ALP3814: Invalid character in numeric constant: The assembler was parsing a numeric constant and an alphabetic character was encountered that was not a valid radix specifier or hexadecimal digit.
ALP3815: Illegal digit(s) for specified radix: A literal integer constant was qualified with radix override, but was specified using digits that are not valid for the given radix qualifier. For instance, use of the literal 1234Y is not legal because the Y suffix specifies a binary number and only the digits 0 and 1 are valid binary digits.
ALP3816: Expecting ">": This message appears when the preprocessor is parsing a <text-item> and the end of line or end of file was encountered. A closing angle bracket (>) was expected.
ALP3817: Unterminated COMMENT: The preprocessor was scanning the body of a COMMENT directive when the end of the current input stream was encountered; the closing delimiter character originally specified in the COMMENT directive was never encountered.; Recovery: Block comments may not span across input files. Provide a closing delimiter as specified in the opening COMMENT directive.

ALP3896: Control character illegal in this context: A COMMENT preprocessor directive was encountered, and an attempt was made to scan for the next character which signifies the beginning and end of the comment text, but an unexpected non-printable control character was encountered instead.; Recovery: Only characters that are representable as printable text may be used to open and close a COMMENT sequence.
ALP3897: No closing quote: The preprocessor was parsing a quoted string literal, and the end of line or other terminator was encountered before the literal was ended with a closing quote character.; Recovery: Verify that only single quotes (´´) or double quotes ("") are used to open and close a string literal; they must be used in pairs. Verify that the ending quote character was not immediately preceded by another identical quote character; the assembler interprets this sequence as a request to insert a quote character into the string literal.
ALP3898: Unexpected end of file: The lexical analyzer portion of the assembler preprocessor was scanning within the body of a token (for example, a block comment), when the end of the input stream was encountered.
ALP3899: Unexpected terminator: The lexical analyzer portion of the assembler preprocessor was performing a text substitution operation as directed by one of the "!" or "&" operators, when the end of file or internal macro buffer was encountered.

Message Numbers 4000-4999: Warning Messages

Warning messages are issued when the assembler detects a questionable construct in the input stream. The condition is not severe enough to prevent generation of an object file, but the situation should be investigated and corrected since the output program may be incorrect.

ALP4201: Offset operator applied to register-indirect expression: An OFFSET operator was applied to a register-indirect expression. In MASM 5.10 emulation mode this does not cause conversion to an immediate expression; instead the register-indirect addressing mode attributes are retained, and the assembler applies the OFFSET operator to the displacement field, forcing it to have the size of the address offset. Applying the OFFSET operator to a register-indirect expression is illegal if the assembler is not operating under MASM 5.10 emulation.
ALP4202: Invalid type expression; cannot convert: Under MASM 5.10 emulation, a constant numeric expression may be used as the left-hand operand of the PTR operator. In the referenced expression, the left-hand operand of the PTR operator did not evaluate to a value suitable for use as the operand size of the right-hand operand. The operand size of the right-hand operator was not converted.
ALP4203: Type conversion operation has no effect: A type conversion operation involving the PTR operator was performed on an expression whose type cannot be modified. For example, the right operand of the PTR operator cannot be a register value.

ALP4401: Error closing listing file: An error occurred while attempting to close the referenced file.; Recovery: Verify that no other processes are accessing the file, and that the file system is functioning correctly.
ALP4402: Error deleting listing file: An error occurred while attempting to delete the referenced file.

Recovery: Verify that no other processes are accessing the file, and that the file system is functioning correctly.

ALP4501: Assuming NEAR distance for operand size: A CALL or JMP instruction was coded to pass control indirectly through a memory operand of indeterminate size. When operating in MASM 5.10 emulation mode, the memory operand is assumed to have the same size as address size of the segment containing the CALL or JMP instruction, and implies a target having NEAR distance.; Recovery: The memory operand should be given an explicit size, regardless of whether or not the default address size and NEAR distance is the desired operation. This code will cause assembly errors if not assembled under MASM 5.10 emulation mode.
ALP4502: Can't ASSUME CS to a grouped segment: An attempt was made to ASSUME the CS register to a segment that was previously named in a GROUP directive. This implies that the CS register might have different values to access the same body of code at runtime. This is illegal, and the assembler altered the ASSUME operation to refer to the group containing the segment instead.; Recovery: If running the assembler under MASM 5.10 emulation, change the ASSUME directive to refer to the group name containing the segment; otherwise, remove the ASSUME statement.
ALP4503: Operand size does not match instruction: This is a warning message that appears when an operand specifies a size that differs from the operand size of the instruction. In this case, the operand size is implied by the instruction itself, and an explicit operand size is not required. However, if an operand size is supplied, it must match the implied size or this warning will be issued.
ALP4504: [Constant] is immediate in MASM mode: This message indicates that a single expression coded as a constant value in square brackets [ ] is treated as though the brackets were not specified (when the assembler is operating in MASM emulation mode, which is the default). This warning is issued because brackets are required for an indirect memory expression when registers are involved, and the connotation is that the presence of brackets is required to force a memory reference, when in fact they are ignored.; Recovery: Use a segment override (for example, DS:[1234h]) when an indirect memory reference to an absolute address is desired. As explained above, the presence of brackets shown in the example is not required, but they are preferred for readability.; Note: A future release may provide an alternate mode of operation such that bracketed constant values will be treated as memory references; this warning message thus points out constructs that are incompatible with any future releases operating in this mode. Since the presence of brackets are currently redundant in this context (and indicate a possible programming error), it is recommended that they be removed.
ALP4505: Access to data through a code label: This warning occurs when an instruction attempts a memory access through a code label (a procedure name or a label followed by a colon). This is an invalid operation unless a type conversion is first performed on the expression containing the label.
ALP4506: Selected processor does not support this instruction: This message is issued under the same circumstances as message ALP3522, but has reduced severity when the assembler is operating under MASM emulation.
ALP4507: Only storing NEAR portion of FAR pointer: Within a data allocation directive, a variable was initialized to contain the address of a FAR code label or variable defined in another segment. However, the size of the variable being initialized is not large enough to hold the fully qualified address (both segment and offset) of the item, and only the offset portion was stored.; Recovery: If the full address of the pointer is desired, then the size of the data item being initialized must be increased. Otherwise, the OFFSET operator should be used in the address expression to truncate the segment information and suppress this warning.
ALP4508: Operand size inferred from immediate value: When operating under MASM 5.10 emulation mode, the assembler allows an immediate value to determine the size of the memory operand to which it is applied if its magnitude exceeds that which will fit into a byte. In this case, it is assumed that the operation refers to a word-sized memory operand (2 bytes in USE16 segment, 4 bytes in a USE32 segment). If the magnitude of the immediate value is sufficiently small (less than 128), then the operation is ambiguous, and an error is generated because the assembler does not know whether to treat the memory operand as a byte or a word value.

Recovery: An explicit size should be given to the memory operand. Code relying on this behavior will not assemble correctly if the assembler is not operating in MASM 5.10 emulation mode.

ALP4509: Operand size mismatch:One of the following conditions occurred:

An attempt was made within a data allocation directive to initialize an item with an expression having an explicit and different size.
A memory operand with an explicit size was used in conjunction with a register operand, but two operand sizes did not match. The register operand size overrides the size of the memory operand.
A memory operand with an explicit size was used in conjunction with an address offset. The size of the memory operand and the size implied by the address size of the offset value did not match.

ALP4510: Truncation of significant bits in immediate value:One of the following conditions occurred:

An operand expression was encoded into the instruction as an immediate value, but the magnitude of the numeric expression exceeded the number of bits required to store it in instruction encoding; the value was truncated to fit in the allotted space.

Since the assembler uses 32-bit arithmetic during expression processing, operations such as negation or logical inversion of small numeric quantities can result in values that require all 32 bits of precision.

A relocatable immediate expression was converted to a smaller type, thus affecting the type of the relocation record generated for resolution by the linker. This could happen if an offset expression was forced into a byte sized storage space.

Recovery: Use the <type> PTR override to explicitly convert the expression to a value of the proper size.

ALP4512: Can't ASSUME CS to different segment or group; ignored:

Within an open segment, an attempt was made to ASSUME the CS register to a different segment, or to a group not containing the currently opened segment. The operation was not allowed. Recovery: Remove the ASSUME statement, or adjust it so that it specifies the currently opened code segment or a group containing the segment.

ALP4513: Invalid mnemonic/operand combination:

This message is issued under circumstances similar to that of message ALP3505. In this case an instruction encoding was found for the given mnemonic/operand combination, but the encoding is considered invalid when the assembler is not operating under this level of MASM emulation; thus this warning is issued.

ALP4514: No size for operand, assuming default:

This message indicates that no operand size was given for the instruction, but the assembler was able to infer an operand size from the instruction itself. This message is only issued when the assembler is operating under MASM 5.10 emulation. In this mode, a default operand size is associated with certain processor mnemonics; this default value is used when no explicit operand size is given. Recovery: An explicit operand size should be given for the referenced expression because the assembler is automatically resolving a potentially dangerous ambiguity in its selection of a default operand size.

ALP4601: Error closing object file:

An error occurred while attempting to close the referenced file. Recovery: Verify that no other processes are accessing the file, and that the file system is functioning correctly.

ALP4602: Error deleting object file:

An error occurred while attempting to delete the referenced file. Recovery: Verify that no other processes are accessing the file, and that the file system is functioning correctly.

ALP4603: Missing END:

The end of file was encountered but an END directive was never processed. All top-level assembler modules invoked from the command line must have an END directive as the last statement in the file. Files processed with the INCLUDE preprocessor directive should not contain an END statement.

ALP4701: Unterminated PROC:

When the end of the source input stream was encountered, it was determined that a procedure was opened with a PROC directive, but never closed. Recovery: Any procedures opened with PROC must be closed within the same input stream using the ENDP directive.

ALP4702: Unterminated segment "":When the end of the source input stream was encountered, it was determined that a segment was opened with a SEGMENT directive, but never closed.

Recovery: Any segments opened with SEGMENT must be closed within the same input stream using the ENDS directive.

ALP4703: Unterminated structure or union====

When the end of the source input stream was encountered, it was determined that a structure or union was opened with a STRUC/STRUCT or UNION directive , but never closed. Recovery: Any structure or union must be terminated using the ENDS directive.

ALP4704: Address size mismatch====

The referenced address expression was used as a source operand, but the address size of the expression did not match the size of the target operand . An implicit conversion was applied to the address size of the referenced expression.

ALP4706: Processor mnemonic used as a label====

This message is issued when a processor instruction mnemonic is used as an identifier. This condition is normally an error if the +Sk command line switch is turned off. Related Information:

Sk - Control Use of Reserved Words as Labels

ALP4707: Alignment value not valid with current segment alignment:

The referenced alignment factor was less than the alignment factor specified in the SEGMENT declaration containing the ALIGN statement. This condition is illegal because the assembler cannot guarantee that the linker will not invalidate the requested alignment when it exercises its right to position the entire segment according to the alignment factor given in the enclosing SEGMENT declaration. Note: This condition is allowed to exist as a warning under MASM 5.10 emulation for backward compatibility with existing source files. Recovery: Respecify either the alignment factor or the SEGMENT declaration so that the segment alignment is greater than or equal to any alignment factor requested therein.

ALP4708: Symbol redeclared relative to different segment====

This message is issued under the same circumstances as message ALP3728, but has reduced severity when the assembler is operating under MASM emulation.

ALP4709: Label outside segment boundaries====

This message is issued under the same circumstances as message ALP3713, but has reduced severity when the assembler is operating under MASM 5.10 emulation.

ALP4710: Identifier expected====

This message is issued under the same circumstances as message ALP3731, but has reduced severity when the assembler is operating under MASM 5.10 emulation.

ALP4711: Attribute respecification ignored====

An attempt was made in a directive to change an attribute that has already been specified. Once set, the attribute cannot be changed. If the attribute is respecified, it must match the existing setting or this warning will be issued.

ALP4712: Mismatch of segment address sizes in group====

This message is issued under the same circumstances as message ALP3747, but has reduced severity when the assembler is operating under MASM 5.10 emulation.

ALP4713: Attribute mismatch during reopen of segment====

This message is issued under the same circumstances as message ALP3729, but has reduced severity when the assembler is operating under MASM 5.10 emulation.

ALP4801: Identifier expected, condition is false:

For compatibility with MASM, the IFDEF and IFNDEF preprocessor directives will accept a non-identifier token as an argument, but this warning is issued to indicate that the condition cannot be properly tested, and the result is always false. Recovery: Modify the argument so that it is a correctly formed identifier.

ALP4802: Extra data on line:This message appears under the same conditions as that of ALP3804, but for better compatibility with MASM the severity has been reduced from an error to a warning. This message will be issued if an IFDEF, IFNDEF, ELSEIFDEF, or ELSEIFNDEF directive contains extra data at the end of the line.

Recovery: Remove the offending token(s) beginning at the referenced location.

ALP4803: Expecting ">":

This message appears when the preprocessor is parsing a <text-item> and the end of line or end of file was encountered. A closing angle bracket (>) was expected.

ALP4804: Expression expected, zero assumed:

For compatibility with MASM, certain preprocessor directives that expect an expression operand will not issue an error if the operand is absent. This warning is issued instead to indicate that an implicit expression value of zero is assumed.

ALP4899: Illegal character:

This message is issued by the text preprocessor when a character was encountered in the source stream that is not part of the valid execution character set. Recovery: This may cause undefined behaviors, and a text editor should be used to remove the offending character.

Message Numbers 5000-5999: Informational Messages

Informational messages may be requested with a command line option (see #M - Control Individual Messages or Groups) and provide the user with a variety of useful information. All informational messages are disabled by default.

ALP5001: Number of Errors :<number>: Informs the user of the number of error messages issued during the assembly.
ALP5002: Number of Warnings :<number>: Informs the user of the number of warning messages issued during the assembly.
ALP5003: Number of Symbols :<number>: This message indicates how many user identifiers were defined during the assembly.

ALP5101: Opened message output file "<file>": This message indicates that the message output processor has opened and is prepared to write to the referenced file.

ALP5201: Operand is declared relative to "<identifier>": This message indicates that the referenced relocatable expression is declared relative to the given segment or group name.

ALP5301: Assembler is on source pass <number>: This messages indicates that the assembler has begun processing the referenced pass through the input stream.

ALP5401: Closed listing output file "<file>": This message indicates that the listing file processor has closed the referenced file.
ALP5402: Deleted listing output file "<file>": This message indicates that the listing file processor has deleted the referenced file.
ALP5403: Opened listing output file "<file>": This message indicates that the listing file processor has opened and is prepared to write to the referenced file.

ALP5501: Address size is <USE16/USE32>: This message provides information to supplement the occurrence of other related warning or error messages. The expression referenced by the message coordinates has inherited or has been assigned the address size given in the message text.
ALP5502: No size for operand, assuming default: This message indicates that no operand size was given for the instruction, but the assembler was able to infer an operand size from the instruction itself.
ALP5503: Instruction padded with NOP(s): This message indicates that the assembler generated one or more NOP instructions to follow the object code generated for the referenced instruction. The instruction operand list contains a forward-referenced expression which forced the assembler to allow space for the longest possible instruction encoding on the first pass. The generation of NOP instructions may be avoided by qualifying the forward reference with a <type> PTR override.
ALP5504: Operand size is <number>: This is an informational message that typically accompanies other errors or warnings dealing with operand size problems. This message is issued for every operand expression involved in the condition that caused the associated error or warning message, and indicates the operand size of the referenced expression.
ALP5505: Segment override has no effect: This message is issued when a segment override operator was used in an expression, but the override was discarded because the offset operator was applied.
ALP5506: Generated ASSUME CS: <signal>:This message is issued when an attempt is made to generate code in an open segment for which there is no valid ASSUME CS in effect. The assembler automatically generates an ASSUME statement such that the CS register is associated with the currently opened segment or with the group containing that segment if one exists.

ALP5601: Closed object output file "<file>": This message indicates that the object file processor has closed the referenced file.
ALP5602: Deleted object output file "<file>": This message indicates that the object file processor has deleted the referenced file.
ALP5603: Opened object output file "<file>": This message indicates that the object file processor has opened and is prepared to write to the referenced file.

ALP5701: Assembly terminated by .ABORT: The .ABORT directive was used to terminate the assembler at the referenced location.
ALP5702: Address size assumed to be <USE16/USE32>: This messages indicates that the referenced identifier was an external code label declared outside of segment boundaries, and was assumed to be defined in an external segment having the referenced address size.
ALP5703: Structure redefinition: "<identifier>":This message indicates that the current structure definition is replacing a previous definition of the same name.
ALP5704: Declaration sets <attribute> = <keyword>: This message describes the attribute that is mismatched in a segment redeclaration.
ALP5705: <directive> outside of segment boundaries: This message appears when an external declaration (COMM or EXTRN) appears outside of any enclosing segment.; If an external declaration is not enclosed in a segment definition that describes how the external symbol is ultimately defined, the assembler is deprived of segment attribute information; in particular, USE16 versus USE32. This could cause the assembler to generate incorrect object code, and may also cause linker errors.; Recovery: Place the external declaration within a segment definition that correctly reflects the segment definition in the external module where the symbol is defined.

ALP5801: Begin skipping tokens: This message indicates that the results of a conditional assembly directive were evaluated to be false, and that the preprocessor has begun discarding tokens at the referenced location. No tokens will be returned to the parser until an appropriate ELSE or ENDIF condition is encountered.
ALP5802: Finished skipping tokens: This message indicates that a false conditional block was ended with an appropriate ELSE or ENDIF construct. The preprocessor will begin returning tokens to the parser after the referenced location.
ALP5803: Closed source file "<file>": This message indicates that the preprocessor has closed the referenced file.
ALP5804: Opened source file "<file>": This message indicates that the preprocessor has opened and is prepared to read from the referenced file.
ALP5805: Macro redefinition: "<macro-name>":This message indicates that the current macro definition is replacing a previous definition of the same name.
ALP5806: Opened INCLUDE file "<file>": This message indicates that the preprocessor has opened and is prepared to read from the referenced include file.
ALP5807: Closed INCLUDE file "<file>": This message indicates that the preprocessor has closed the referenced include file.

ALP5901: Closed response file "<file>": This message indicates that the command line processor has closed the referenced file.
ALP5902: Opened response file "<file>": This message indicates that the command line processor has opened and is prepared to read from the referenced file.