A1

ILLEGAL CHARACTER IN NUMERIC CONSTANT:
This error indicates that an invalid character was found in a numeric constant. Numeric constants must begin with a decimal digit and are delimited by the first non–numeric character (with the exception of the dollar sign). The base of the number decides which characters are valid.

Base 2: 0, 1 and the base indicator B

Base 8: 0–7 and the base indicator O or Q

Base 10: 0–9 and the base indicator D or no indicator

Base 16: 0–9, A–F and the base indicator H

Base 16: 0xhhhh, 0–9, and A–F

Symptoms:

Cause:

Example


A2

MISSING STRING TERMINATOR:
The ending string terminator was missing. The string was terminated with a carriage return.


A3

ILLEGAL CHARACTER:
The assembler has detected a character which is not in the set of valid characters for the 51/251 assembler language (for example `).


A4

BAD INDIRECT REGISTER IDENTIFIER:
This error occurs if combined registers are entered incorrectly; e.g.,

@R7, @R3, @PC+A, @DPTR+A.


A5

ILLEGAL USE OF A RESERVED WORD :
This error indicates that a reserved word is used for a label.


A6

DEFINITION STATEMENT EXPECTED:
The first symbol in the line must be part of a definition. For example:

VAR1 EQU 12


A7

LABEL NOT PERMITTED:
A label was detected in an invalid context.


A8

ATTEMPT TO DEFINE AN ALREADY DEFINED LABEL:
A label was defined more than once. Labels may be defined only once in the source program.


A9

SYNTAX ERROR:
A51/A251 encountered an error processing the line at the specified token.


A10

ATTEMPT TO DEFINE AN ALREADY DEFINED SYMBOL:
An attempt was made to define a symbol more than once. The subsequent definition was ignored.


A11

STRING CONTAINS ZERO OR MORE THAN TWO CHARACTERS:
Strings used in an expression can be a maximum of two characters long (16 bits).


A12

ILLEGAL OPERAND:
An operand was expected but was not found in an arithmetic expression. The expression is illegal.


A13

')' EXPECTED:
A right parenthesis is expected. This usually indicates an error in the definition of external symbols.


A14

BAD RELOCATABLE EXPRESSION:
A relocatable expression may contain only one relocatable symbol which may be a segment symbol, external symbol, or a symbol belonging to a relocatable segment. Mathematical operations cannot be carried out on more than one relocatable symbol.


A15

MISSING FACTOR:
A constant or a symbolic value is expected after an operator.


A16

DIVIDE BY ZERO ERROR:
A division by zero was attempted while calculating an expression. The value calculated is undefined.


A17

INVALID BASE IN BIT ADDRESS EXPRESSION:
This error indicates that the byte base in the bit address is invalid. This occurs if the base is outside of the range 20h–2Fh or if it lies between 80h and 0FFh and is not evenly divisible by 8. For the 251 chip, the byte base address must be in range 20H-0FFH with no restrictions. Note that with symbolic operands, the operand specifies an absolute bit segment or an addressable data segment.


A18

OUT OF RANGE OR NON–TYPELESS BIT–OFFSET:
The input of the offset (base.offset) in a bit address must be a typeless absolute expression with a value between 0 and 7.


A19

INVALID REGISTER FOR EQU/SET:
The registers R0–R7, A and C may be used in SET or EQU directives. No other registers are allowed.


A20

INVALID SIMPLE RELOCATABLE EXPRESSION:
A simple relocatable expression is intended to represent an address in a relocatable segment. External symbols as well as segment symbols are not allowed. The expression however may contain more symbols of the same segment. Simple relocatable expressions are allowed in the instructions ORG, EQU, SET, CODE, XDATA, IDATA, BIT, DATA, DB and DW.


A21

EXPRESSION WITH FORWARD REFERENCE NOT PERMITTED:
Expressions in EQU and SET directives may not contain forward references.


A22

EXPRESSION TYPE DOES NOT MATCH INSTRUCTION:
The expression does not conform to the 8051/251 conventions. A #, /Bit, register, or numeric expression was expected.


A23

NUMERIC EXPRESSION EXPECTED:
A numeric expression is expected. The expression of another type is found.


A24

SEGMENT–TYPE EXPECTED:
The segment type of a definition was missing or invalid.


A25

RELOCATION–TYPE EXPECTED:
An invalid relocation type for a segment definition was encountered. One of the following is valid: UNIT, PAGE, INPAGE, INBLOCK and BITADDRESSABLE (for A251: same as before plus INSEG and EBITADDRESSABLE).


A26

INVALID RELOCATION–TYPE:
The types PAGE and INPAGE are only allowed for the CODE/ECODE and XDATA segments. INBLOCK/INSEG is only allowed for the CODE/ECODE segments and BITADDRESSABLE is only for the DATA segment (maximum length 16 Bytes). EBITADDRESSABLE is allowed for DATA segments (maximum length 96 Bytes). The type UNIT is the default for all segment types if no input is entered.


A27

LOCATION COUNTER MAY NOT POINT BELOW SEGMENT–BASE:
An ORG directive used in a segment defined by the AT address directive may not specify an offset that lies below the segment base. The following example is, therefore, invalid:

CSEG AT 1000H
ORG 800H


A28

ABSOLUTE EXPRESSION REQUIRED:
The expression in a DS or DBIT instruction must be an absolute typeless expression. Relocatable expressions are not allowed.


A29

SEGMENT–LIMIT EXCEEDED:
The maximum limit of a segment was exceeded. This limit depends on the segment and relocation type. Segments with the attribute DATA should not exceed 128 bytes. BITADDRESSABLE segments should not exceed 16 bytes and INPAGE segments should not exceed 2 KBytes.


A30

SEGMENT–SYMBOL EXPECTED:
The operand to an RSEG directive must be a segment symbol.


A31

PUBLIC–ATTRIBUTE NOT PERMITTED:
The PUBLIC attribute is not allowed on the specified symbol.


A32

ATTEMPT TO RESPECIFY MODULE NAME:
An attempt was made to redefine the name of the module by using a second NAME directive. The NAME directive may only appear once in a program.


A33

CONFLICTING ATTRIBUTES:
A symbol may not contain the attributes PUBLIC and EXTRN simultaneously.


A34

',' EXPECTED:
A comma is expected in a list of expressions or symbols.


A35

'(' EXPECTED:
A left parenthesis is expected at the indicated position.


A36

INVALID NUMBER FOR REGISTERBANK:
The expression in a REGISTERBANK control must be an absolute typeless number between 0 and 3.


A37

OPERATION INVALID IN THIS SEGMENT:
8051/251 instructions are allowed only within CODE/ECODE segments.


A38

NUMBER OF OPERANDS DOES NOT MATCH INSTRUCTION:
Either too few or too many operands were specified for the indicated instruction. The instruction was ignored.


A39

REGISTER–OPERAND EXPECTED:
A register operand was expected but an operand of another type was found.


A40

INVALID REGISTER:
The specified register operand does not conform to the 8051/251 conventions.


A41

MISSING 'END' STATEMENT:
The last instruction in a source program must be the END directive. The preceding source is assembled correctly and the object is valid.


A42

INTERNAL ERROR (PASS-2), CONTACT TECHNICAL SUPPORT:
This error occurs if a symbol in Pass 2 contains a value different than in Pass 1.


A43

RESPECIFIED PRIMARY CONTROL, LINE IGNORED:
A control was repeated or conflicts with a previous control. The control statement was ignored.


A44

MISPLACED PRIMARY CONTROL, LINE IGNORED:
A primary control was misplaced. Primary controls may be entered in the invocation line or at the beginning of the source file (as $ instruction). The processing of primary controls in a source file ends when the first non empty/non comment line containing anything but a primary control is processed.


A45

UNDEFINED SYMBOL (PASS–2):
The symbol is undefined.


A46

CODE/ECODE–ADDRESS EXPECTED:
An operand of memory type CODE/ECODE or a typeless expression is expected.


A47

XDATA–ADDRESS EXPECTED:
An operand of memory type XDATA or a typeless expression is expected.


A48

DATA–ADDRESS EXPECTED:
An operand of memory type DATA or a typeless expression is expected.

Symptoms:

Cause:

Example

A49
IDATA–ADDRESS EXPECTED:
An operand of memory type 'IDATA' or a typeless expression is expected.


A50

BIT–ADDRESS EXPECTED:
An operand of memory type BIT or a typeless expression is expected.


A51

TARGET OUT OF RANGE:
The target of a conditional jump instruction is outside of the +127/–128 range or the target of an AJMP or ACALL instruction is outside the 2 KByte memory block.


A52

VALUE HAS BEEN TRUNCATED TO 8 BITS:
The result of the expression exceeds 255 decimal. Only the 8 low–order bits are used for the byte operand.


A53

MISSING 'USING' INFORMATION:
The absolute register symbols AR0 through AR7 can be used only if a USING registerbank directive was specified. This error indicates that the USING directive is missing and the assembler cannot assign data addresses to the register symbols.


A54

MISPLACED CONDITIONAL CONTROL:
An ELSEIF, ELSE, or ENDIF control must be preceded by an IF instruction.


A55

BAD CONDITIONAL EXPRESSION:
The expression to the IF or ELSEIF control is invalid. These expressions must be absolute and may not contain relocatable symbols.

The $IF and $ELSEIF can only access symbols defined with the $SET and $RESET controls. Both IF and ELSEIF allow access to all symbols of the source program.


A56

UNBALANCED IF–ENDIF–CONTROLS:
Each IF block must be terminated with an ENDIF control. This is also true with skipped nested IF blocks.


A57

SAVE STACK UNDERFLOW:
A $RESTORE control instruction is then valid only if a $SAVE control was previously given.


A58

SAVE STACK OVERFLOW:
The context of the GEN, COND, and LIST controls may be stored by the $SAVE control up to a maximum of 9 levels.


A59

MACRO REDEFINITION:
An attempt was made to define an already defined macro.


A60

ERROR-60:
Not generated by A51/251.


A61

MACRO TERMINATED BY END OF FILE, MISSING 'ENDM':
An attempt was made to define an already defined macro.


A62

TOO MANY FORMAL PARAMETERS (16):
The number of formal parameters to a macro is limited to 16.


A63

TOO MANY LOCALS (16):
The number of local symbols within a macro is limited to 16.


A64

DUPLICATE LOCAL/FORMAL:
The number of local or formal identifier must be distinct.


A65

IDENTIFIER EXPECTED:
While parsing a macro definition, an identifier was expected but something different was found.


A66

'EXITM' INVALID OUTSIDE A MACRO:
The EXITM (exit macro) keyword is illegal outside a macro definition.


A67

EXPRESSION TOO COMPLEX:
A too complex expression was encountered. This error occurs, if the number of operands and operators in one expression exceeds 50.


A68

UNKNOWN CONTROL OR BAD ARGUMENT(S):
The control given in a $-control line or the argument(s) to some control are invalid.


A69

MISPLACED ELSEIF/ELSE/ENDIF CONTROL:
These controls require a preceding IF control.


A70

LIMIT EXCEEDED: IF-NESTING (10):
IF controls may be nested up to a level of 10.


A71

NUMERIC VALUE OUT OF RANGE:
The value of a numeric expression is out of range (for example $PAGEWIDTH (2048) where only values in range 80 to 132 are allowed).


A72

TOO MANY TOKENS IN SOURCE LINE:
The number of tokens (identifiers, operators, punctuation characters and end of line) exceeds 200. The source line is truncated at 200 tokens.


A73

TEXT FOUND BEYOND END STATEMENT - IGNORED:
Text following the END directive is not processed by the assembler.


A74

REGISTER USAGE: UNDEFINED REGISTER NAME:
A register name argument given to the REGUSE control does not represent the name of a register.


A75

'REGISTER USAGE' REQUIRES A PUBLIC CODE SYMBOL:
The register usage value must be assigned to a public symbol, which represents a CODE symbol. For the A251, the name of a public procedure (near of far) with memory type CODE/ECODE is also valid.


A76

MULTIPLE REGISTER USES GIVEN TO ONE SYMBOL:
The register usage value may be assigned to a symbol or procedure only once.


A77

INSTRUCTION NOT AVAILABLE †:
The given instruction is not available in the current mode of operation.


A78

ERROR 78:
Not generated by A51/251.


A79

INVALID ATTRIBUTE †:
The OVERLAYABLE attribute given in a segment definition is not valid for code and constant segments.


A80

INVALID ABSOLUTE BASE/OFFS VALUE †:
The absolute address given in a segment definition does not conform to the memory type of the segment (for example DATA AT 0x1000).


A81

EXPRESSION HAS DIFFERENT MEMORY SPACE †:
The expression given in a symbol definition statement does not have the memory space required by the directive, for example:

VAR1 CODE EXPR

where 'EXPR' has a memory type other than CODE or NUMBER.


A82

LABEL STATEMENT MUST BE WITHIN CODE/ECODE SEGMENT †:
The LABEL statement is not allowed outside a CODE or ECODE segment.


A83

TYPE INCOMPATIBLE WITH GIVEN MEMORY SPACE †:
The type given in an external declaration is not compatible to the given memory space. The following examples shows an invalid type since a bit can never reside in code space:

EXTRN CODE:BIT (bit0, bit1)


A84

OPERATOR REQUIRES A CODE/ECODE ADDRESS:
The type override operators NEAR and FAR cannot be applied to addresses with memory type other than CODE and ECODE.


A85

INVALID OPERAND TYPE †:
An expression contains invalid typed operands to some operator, for example addition/unary minus on bit-type operands.


A86

PROCEDURES CAN´T BE NESTED:
A251 does not support nested procedures.


A87

UNCLOSED PROCEDURE †:
A251 detected an unclosed procedure after scanning the source file.


A88

VALUE HAS BEEN TRUNCATED TO 16 BITS:
The displacement value given in a register expression (WRn+disp16, DRk+disp16) has been truncated to 16 bits.


A89

ERROR-89 †:
Not generated by A51/251.


A90

'FAR' RETURN IN 'NEAR' PROCEDURE †:
The return far instruction (ERET) was encountered in a procedure of type NEAR (the code may not work).


A91

TYPE MISMATCH †:
The operand type of an instruction operand does not match the requested type of the instruction, for example:

MOV WR10,Byte_Memory_Operand. ; Word/Byte mismatch

Use a type override to avoid the warning as shown:

MOV WR10,WORD Byte_Memory_Operand


A92

MCS 251 INSTRUCTION IN NON 251 MODE †:
The assembler encountered an MCS 251 instruction in $NOMOD251 mode of operation. $NOMOD251 limits the instructions to the set for the MCS 51 family of controllers.


A93

ERROR-93:
Not generated by A51/251.


A94

VALUE DOES NOT MATCH INSTRUCTION †:
The short value given in a INC/DEC Rn,#short is not one of 1,2,4.


A95

ILLEGAL MEMORY CLASS SPECIFIER †:
The memory class specifier in a segment definition statement does not correspond to one of the predefined memory class names (CODE, ECODE, BIT, EBIT ...).


A96

ACCESS TO MISALIGNED ADDRESS †:
A word instruction accesses a misaligned (odd) address. This warning is generated only if the $WORDALIGN control was given.


A97

'FAR' REFERENCE TO 'NEAR' LABEL †:
An ECALL/AJMP instruction to some label of type NEAR has been detected.


A98

'NEAR' REFERENCE TO 'FAR' LABEL †:
An ACALL/AJMP/SJMP or conditional jump instruction to some label of type FAR has been detected.


A150

PREMATURE END OF FILE ENCOUNTERED:
The MPL macro processor encountered the end of the source file while parsing a macro definition.


A151

<name> IDENTIFIER EXPECTED:
The macro or function given by <name> in the error message expected an identifier but found something else.


A152

MPL FUNCTION <name> <character> EXPECTED:
The MPL function <name> expected a specific character in the input stream but found some other character.


A153

<name>: UNBALANCED PARENTHESIS:
While scanning balanced text, the macro processor expected a ')' character, but found some other character.


A154

EXPECTED <identifier>:
The macro processor expected some specific identifier (for example ELSE) but found some other text.


A155

ERROR-155:
Not generated by A51/251.


A156

FUNCTION 'MATCH': ILLEGAL CALL PATTERN:
The call pattern to the MPL function match must be a formal parameter followed by a delimiter followed by another formal parameter.


A157

FUNCTION 'EXIT' IN BAD CONTEXT:
The EXIT function must not appear outside a macro expansion, %REPEAT or %WHILE.


A158

ILLEGAL METACHARACTER <character>:
The metacharacter may not be @, (, ), *, TAB, EOL, A-Z,a-z, 0-9, _ and ?.


A159

CALL PATTERN - DELIMITER <delimiter> NOT FOUND:
The actual parameters in a macro call do not match the call pattern defined in the macro definition of that macro.


A160

CALL TO UNDEFINED MACRO <macroname>:
An attempt to activate an undefined macro has been encountered .


A161

ERROR-161:
Not generated by A51/251.


A162

INVALID DIGIT 'character' IN NUMBER:
An ill formed number has been encountered. For numbers, the rules are equal to the numbers in the assembler language with the exception of $ signs, which are not supported within the MPL.


A163

UNCLOSED STRING OR CHARACTER CONSTANT:
A string or character constant is terminated by an end of line character instead of the closing character.


A164

INVALID STRING OR CHARACTER CONSTANT:
A string or character constant may contain one or two characters.


A165

EVAL: UNKNOWN EXPRESSION IDENTIFIER:
An MPL expression contains an unknown identifier.


A166

<token>: INVALID EXPRESSION TOKEN:


A167

<function>: DIV/MOD BY ZERO:
An MPL expression contains a token which neither represents an operator nor an operand.


A168

EVAL: SYNTAX ERROR IN EXPRESSION:
An expression is followed by one or more erroneous tokens.


A169

CAN'T OPEN FILE <name of file>:
The file given in an $INCLUDE directive cannot be opened.


A170

<name of file>: IS NOT A DISK FILE:
An attempt was made to open a file which is not a disk file (for example $INCLUDE (CON).


A171

ERROR IN INCLUDE DIRECTIVE:
The argument to the INCLUDE directive must be the brace enclosed name of the file, for example $INCLUDE (REG251.INC).


A172

CAN'T REDEFINE PREDEFINED MACRO 'SET':
The .predefined %SET macro can't be redefined.


C100

Unprintable character 0x?? skipped:
An illegal character was found in the source file. (Note that characters inside a comment are not checked.)


C101

Unclosed string:
A string is not terminated with a quote (").


C102

String too long:
A string may not contain more than 4096 characters. Use the concatenation symbol ('\') to logically continue strings longer than 4096 characters. Lines terminated in this fashion are concatenated during lexical analysis.


C103

Invalid character constant :
A character constant has an invalid format. The notation '\c' is valid only when c is any printable ASCII character.


C125

Declarator too complex (20):
The declaration of an object may contain a maximum of 20 type modifiers ('[', ']', '*', '(', ')'). This error is almost always followed by error 126.


C126

Type-stack underflow:
The type declaration stack has underflowed. This error is usually a side-effect of error 125.


C127

Invalid storage class:
An object was declared with an invalid memory space specification. This occurs if an object is declared with storage class of auto or register outside of a function.


C129

Missing ; before token:
This error usually indicates that a semicolon is missing from the previous line. When this error occurs, the compiler may generate an excess of error messages.


C130

Value out of range:
The numerical argument after a using or interrupt specifier is invalid. The using specifier requires a register bank number between 0 and 3. The interrupt specifier requires an interrupt vector number between 0 and 31.


C131

Duplicate function-parameter:
A formal parameter name exists more than once within a function. The formal parameter names must be unique in function declarations.


C132

Not in formal parameter list:
The parameter declarations inside a function use a name not present in the parameter name list. For example:

Symptoms:

Cause:

Example

char function (v0, v1, v2)
char *v0, *v1, *v5;
/* 'v5' is unknown in the formal list */
{
  /* ... */
}


C134

xdata/idata/pdata/data on function not permitted:
Functions always reside in code memory and cannot be executed out of other memory areas. Functions are implicitly defined as memory type code.


C135

Bad storage class for bit:
Declarations of bit scalars may include one of the static or extern storage classes. The register or alien classes are invalid.


C136

'void' on variable:
The type void is allowed only as a non-existent Symptoms or an empty argument list for functions (void func (void)), or in combination with a pointer (void *).


C138

Interrupt() may not receive or Symptoms(s):
An interrupt function was defined with one or more formal parameters or with a Symptoms. Interrupt functions may not contain invocation parameters or Symptomss.


C140

Bit in illegal memory-space:
Definitions of bit scalars may contain the optional memory type data. If the memory type is missing then the type data is assumed, because bits always reside in the internal data memory. This error can occur when an attempt is made to use another data type with a bit scalar definition.


C141

Syntax error near token: expected other_token, ...:
The token seen by the compiler is wrong. Depending upon the context the expected token is displayed.


C142

Invalid base address:
The base-address of an sfr or sbit declaration is in error. Valid bases are values in the 0x80 to 0xFF range. If the declaration uses the notation base^pos, then the base address must also be a multiple of eight.


C143

Invalid absolute bit address:
The absolute address in sbit declarations must be in the 0x80 to 0xFF range.


C144

Base^pos: invalid bit position:
The definition of the bit position within an sbit declaration must be in the 0 to 7 range.


C145

Undeclared sfr:
The declaration of an absolute bit (base^pos) contains an invalid base-specification. The base must be the name of a previously declared sfr. Any other names are invalid.


C146

Invalid sfr:
The declaration of an absolute bit (base^pos) contains an invalid base-specification. The base must be the name of a previously declared sfr. Any other names are invalid.


C147

Object too large:
The size of a single object may not exceed the absolute limit of 65535 (64 Kbytes -1).


C149

Function member in struct/union:
A struct or union may not contain a function-type member. However, pointers to functions are perfectly valid.


C150

Bit member in struct/union:
A union-aggregate may not contain members of type bit. This restriction is imposed due to the architecture of the 8051.


C151

Self relative struct/union:
A structure cannot contain an instance of itself.


C152

Bit-field type too small for number of bits:

The number of bits specified in the bit-field declaration exceeds the number of bits in the given base type.


C153

Named bit-field cannot have zero width:

The named field had a zero width. Only unnamed bit-fields are allowed to have zero width.


C154

Ptr to field:

Pointers to bit-fields are not valid types.


C155

char/int required for fields:

The base type for bit-fields requires one of the types char or int. unsigned char and unsigned int types are also valid.


C156

Alien permitted on functions only:

The storage class alien is allowed only for external PL/M-51 functions. The formal notation (char *, …) is not legal on alien functions. PL/M-51 functions always require a fixed number of parameters.


C157

Var_parms on alien function:

The storage class alien is allowed only for external PL/M-51 functions. The formal notation (char *, …) is not legal on alien functions. PL/M-51 functions always require a fixed number of parameters.


C158

Function contains unnamed parameter:

The parameter list of a function definition contains an unnamed abstract type definition. This notation is permitted only in function prototypes.


C159

Type follows void:

Prototype declarations of functions may contain an empty parameter list (for example, int func (void)). This notation may not contain further type definitions after void.


C160

void invalid:

The void type is legal only in combination with pointers or as the non-existent Symptoms of a function.


C161

Formal parameter ignored:

A declaration of an external function inside a function used a parameter name list without any type specification.

Symptoms:

Cause:

Example

extern yylex(a,b,c);)


C162

Duplicate function-parameter:

The name of a defined object inside a function duplicates the name of a parameter.


C163

Unknown array size:

In general, a formal size specifier is not required for external, single, or multi-dimensional arrays. Typically, the compiler calculates the size at initialization time. For external arrays, the size is of no great interest. This error is the result of attempting to use the sizeof operator on an undimensioned array or on a multi-dimensional array with undefined element sizes.


C164

Ptr to nul:

This error is usually the result of a previous error for a pointer declaration.


C165

Ptr to bit:

The type combination pointer to bit is not a legal type.


C166

Array of functions:

Arrays cannot contain functions; however, they may contain pointers to functions.


C167

Array of fields:

Bit-fields may not be arranged as arrays.


C168

Array of bit:

An array may not have type bit as its basic type. This limitation is imposed by the architecture of the 8051.


C169

Function returns function:

A function cannot return a function; however, a function may return a pointer to a function.


C170

Function returns array:

A function cannot return an array; however, a pointer to an array is valid.


C171

Missing enclosing loop:

A break or continue statement may occur only within a for, while, do, or switch statement.


C172

Missing enclosing switch:

A case statement may occur only within a switch statement.


C173

Missing return-expression:

A function which returns a value of any type but int, must contain a return statement including an expression. Because of compatibility to older programs, no check is done on functions which return an int value.


C174

Return-expression on void-function:

A void function cannot return a value and thus may not contain a return statement.


C175

Duplicate case value:

Each case statement must contain a constant expression as its argument. The value must not occur more than once in the given level of the switch statement.


C176

More than one 'default':

A switch statement may not contain more than one default statement.


C177

Different struct/union:

Different types of structures are used in an assignment or as an argument to a function.


C178

Struct/union comparison illegal:

The comparison of two structures or unions is not allowed according to ANSI.


C179

Illegal type conversation from/to 'void':

Type casts to or from void are invalid.


C180

Can't cast to 'function':

Type casts to function types are invalid. Try casting to a pointer to a function.


C181

Incompatible operand:

At least one operand type is not valid with the given operator.

Symptoms:

Cause:

Example

~float_type;


C182

:

A pointer was assigned the address of a different type.


C183

Unmodifiable lvalue:

The object to be changed resides in code memory or has const attribute and therefore cannot be modified.


C184

Sizeof: illegal operand:

The sizeof operator cannot determine the size of a function or bit-field.


C185

Different memory space:

The memory space of an object declaration differs from the memory space of a prior declaration for the same object.


C186

Invalid dereference:

This error message may be caused by an internal compiler problem. Please contact technical support if this error is repeated.


C187

Not an lvalue:

The needed argument must be the address of an object that can be modified.


C188

Unknown object size:

The size of an object cannot be computed because of a missing dimension size on an array or indirection via a void pointer.


C189

'&' on bit/sfr illegal:

The address-of operator ('&') is not allowed on bit objects or special function registers (sfr).


C190

'&': not an lvalue:

An attempt was made to construct a pointer to an anonymous object.


C193

Illegal op-type(s), Illegal add/sub on ptr, Illegal operation on bit(s), Bad operand type:

This error results when an expression uses illegal operand-types with the given operator. Examples of invalid expressions are bit * bit, ptr + ptr, or ptr * anything. The error message includes the operator which caused the error.

The following operations may be executed with bit-type operands:

  • Assignment (=)
  • OR / Compound OR (|, |=)
  • AND / Compound AND (&, &=)
  • XOR / Compound XOR (^, ^=)
  • Compare bit with bit or constant (==, !=)
  • Negation (~)

bit operands may be used in expressions with other data types. In this case a type cast is automatically performed.


C194

'*' indirection to object of unknown size:

The indirection operator * may not be used with void pointers because the object size, which the pointer refers to, is unknown.


C195

'*' illegal indirection:

The * operator may not be applied on non-pointer arguments.


C196

Mspace probably invalid:

The conversion of a constant to a pointer constant yields an invalid memory space.

This warning is caused by the assignment of an invalid constant value to a pointer. Valid pointer constants are long or unsigned long. The compiler uses 24 bits (3 bytes) for pointer objects. The low-order 16 bits represent the offset. The high-order 8 bits represent the memory space selector.

Symptoms:

Cause:

Example

*p = 0x91234


C198

Sizeof returns zero:

The sizeof operator returns a zero value or the calculation of the size of an object yields zero. This value may be wrong if the object is external or if not all dimension sizes of an array are known.


C199

Left side of '->' requires struct/union pointer:

The argument on the left side of the -> operator must be a struct pointer or a union pointer.


C200

Left side of '.' requires struct/union:

The argument on the left side of the . operator must have type struct or union.


C201

Undefined struct/union tag:

The given struct or union tag name is unknown.


C202

Undefined identifier:

The given identifier is undefined.


C203

Bad storage class (nameref):

This error indicates a problem within the compiler. Please contact technical support if this error is repeated.


C204

Undefined member:

The given member name in a struct or union reference is undefined.


C205

Can't call an interrupt function:

An interrupt function should not be called like a normal function. The entry and exit code for these functions is specially coded for interrupts.


C206

Missing function prototype:

The called function is unknown because no prototype declaration exists. Calls to unknown functions are always at risk that the number of parameters does not correspond to the actual requirements. If this is the case, the function is called incorrectly.
The compiler has no way to check for missing or excessive parameters and their types. Include prototypes of the functions used in your program. Prototypes must be specified before the functions are actually called. The definition of a function automatically produces a prototype.


C207

Declared with 'void' parameter list:

A function declared with a void parameter list cannot receive parameters from the caller.


C208

Too many actual parameters:

The function call includes more parameters than previously declared.


C209

Too few actual parameters:

Too few actual parameters were included in a function call.


C210

Too many nested calls:

Function calls can be nested at most 10 levels deep.


C211

Call not to a function:

The term of a function call does not evaluate to a function or pointer to function.


C212

Indirect call: parameters do not fit within registers:

An indirect function call through a pointer cannot contain actual parameters. An exception to this rule is when all parameters can be passed in registers. This is due to the method of parameter passing employed by C51. The name of the called function must be known because parameters are written into the data segment of the called function. For indirect calls, however, the name of the called function is not known.


C213

Left side of asn-op not an lvalue:

The address of a changeable object is required at the right side of the assignment operator.


C214

Illegal pointer conversion:

Objects of type bit, float or aggregates cannot be converted to pointers.


C215

Illegal type conversion:

Struct/union/void cannot be converted to any other types.


C216

Subscript on non-array or too many dimensions:

An array reference contained either too many dimension specifiers or the object was not an array.


C217

Non-integral index:

The dimension expression of an array must be of the type char, unsigned char, int, or unsigned int. All other types are illegal.


C218

Void-type in controlling expression:

The limit expression in a while, for, or do statement cannot be of type void.


C219

Long constant truncated to int:

The value of a constant expression must be capable of being represented by an int type.


C220

Illegal constant expression:

A constant expression is expected. Object names, variables or functions, are not allowed in constant expressions.


C221

Non-constant case/dim expression:

A case value or a dimension specification ([ ]) must be a constant expression.


C222

Div by zero:

The compiler detected a division or a modulo by zero.


C223

Mod by zero:

The compiler detected a division or a modulo by zero.


C225

Expression too complex, simplify:

An expression is too complex and must be broken into two or more sub expressions.


C226

Duplicate struct/union/enum tag:

The name for a struct, union, or enum is already defined within current scope.


C227

Not a union tag:

The name for a union is already defined as a different type.


C228

Not a struct tag:

The name for a struct is already defined as a different type.


C229

Not an enum tag:

The name for an enum is already defined as a different type.


C230

Unknown struct/union/enum tag:

The specified struct, union, or enum name is undefined.


C231

Redefinition:

The specified name is already defined and cannot be redefined.


C232

Duplicate label:

The specified label is already defined.


C233

Undefined label:

This message indicates a label that was accessed but was not defined. Sometimes this message appears several lines after the actual label reference. This is caused by the method used to search for undefined labels.


C234

'{', scope stack overflow(31):

The maximum of 31 nested blocks has been exceeded. Additional levels of nested blocks are ignored.


C235

Parameter <number>: different types:

Parameter types in the function declaration are different from those in the function prototype.


C236

Different length of parameter lists:

The number of parameters in the function declaration is different from the number of parameters in the function prototype.


C237

Function already has a body:

An attempt was made to declare a body for a function twice.


C238

Duplicate member:

An attempt was made to define an already defined struct member or function parameter.


C239

Duplicate parameter:

An attempt was made to define an already defined struct member or function parameter.


C240

More than 128 local bit's:

No more than 128 bit-scalars may be defined inside a function.


C241

Auto segment too large:

The required space for local objects exceeds the model-dependent maximum. The maximum segment sizes are defined as follows:

SMALL128 bytes
COMPACT256 bytes
LARGE65535 bytes


C242

Too many initializers:

The number of initializers exceeded the number of objects to be initialized.


C243

String out of bounds:

The number of characters in the string exceeds the number of characters required to initialize the array of characters.


C244

Can't initialize, bad type or class:

An attempt was made to initialize a bit or an sfr.


C245

Unknown pragma, line ignored:

The #pragma statement is unknown so, the entire line is ignored.


C246

Floating-point error:

This error occurs when a floating-point argument lies outside of the valid range for 32-bit floating values. The numeric range of the 32-bit IEEE values is: ±1.175494E-38 to ±3.402823E+38.


C247

Non-address/constant initializer:

A valid initializer expression must evaluate to a constant value or the name of an object plus or minus a constant.


C248

Aggregate initialization needs curly braces:

The braces ({ }) around the given struct or union initializer were missing.


C249

Segment <name>: Segment too large:

The compiler detected a data segment that was too large. The maximum size of a data segment depends on memory space.


C250

'\esc'; value exceeds 255:

An escape sequence in a string constant exceeds the valid value range. The maximum value is 255.


C251

Illegal octal digit:

The specified character is not a valid octal digit.


C252

Misplaced primary control, line ignored:

Primary controls must be specified at the start of the C module before any #include directives or declarations.


C253

Internal error (ASMGEN\CLASS):

This error can occur under the following circumstances:

  • An intrinsic function (for example, _testbit_) was activated incorrectly. This is the case when no prototype of the function exists and the number of actual parameters or their type is incorrect. For this reason, the appropriate declaration files must always be used (intrins.h, string.h). See Chapter 8 for more information on intrinsic functions.
  • C51 recognized an internal consistency problem. Please contact technical support if this error occurs.


C255

Switch expression has illegal type:

The expression in a switch statement has not a legal data type.


C256

Conflicting memory model:

A function which contains the alien attribute may contain only the model specification small. The parameters of the function must lie in internal data memory. This applies to all external alien declarations and alien functions.

Symptoms:

Cause:

Example

alien plm_func (char c) large { ... }   // !! generates error 256 !!


C257

Alien function cannot be reentrant:

A function that contains the alien attribute cannot simultaneously contain the attribute reentrant. The parameters of the function cannot be passed via the virtual stack. This applies to all external alien declarations and alien functions.


C258

Mspace illegal on struct/union member, Mspace on parameter ignored:

A member of a structure or a parameter may not contain the specification of a memory type. The object to which the pointer refers may, however, contain a memory type.

Symptoms:

Cause:

Example

struct vp { char code c; int xdata i; };    // generates error 258
struct v1 { char c; int xdata *i; };        // is the correct declaration for the struct


C259

Pointer: different mspace:

A spaced pointer has been assigned another spaced pointer with a different memory space. This warning is generated when two pointers that do not refer to the same memory type of object are compared.

Symptoms:

Cause:

Example

char xdata *p1;
char idata *p2;
p1 = p2;      /* different memory spaces */


C260

Pointer truncation:

A spaced pointer has been assigned some constant value which exceeds the range covered by the pointers memory space. This error or warning occurs when converting a pointer to a pointer with a smaller offset area. The conversion takes place, but the offset of the larger pointer is truncated to fit into the smaller pointer.

Symptoms:

Cause:

Example

char idata *p1 = 0x1234;   /* result is 0x34 */


C261

Bit(s) in reentrant function( ):

A function with the attribute reentrant cannot have bit objects declared inside the function. A reentrant function cannot contain bits because bit scalars cannot be stored on the virtual stack.

Symptoms:

Cause:

Example

int func1 (int i1) reentrant  {
  bit b1, b2;    /* not allowed ! */
  return (i1 - 1);
}


C262

'using/disable': can't return bit value:

Functions declared with the using attribute and functions which rely on disabled interrupts (#pragma disable) cannot return a bit value to the caller.

Symptoms:

Cause:

Example

bit test (void) using 3
{
  bit b0;        // produces error 262
  return (b0);
}


C263

Save/restore: save-stack overflow/underflow:

The maximum nesting depth #pragma save comprises eight levels. The pragmas save and restore work with a stack according to the LIFO (last in, first out) principal.


C264

Intrinsic '<intrinsic_name>': declaration/activation error:

This error indicates that an intrinsic function was defined incorrectly (parameter number or ellipsis notation). This error should not occur if you are using the standard .h files. Make sure that you are using the .h files that were included with C51. Do not try to define your own prototypes for intrinsic library functions.


C265

Recursive call to non-reentrant function:

Non reentrant functions cannot be called recursively since such calls would overwrite the parameters and local data of the function. If you need recursive calls, you should declare the function with the reentrant attribute.

A direct recursion to a non-reentrant function was discovered. This can be intentional but should be functionally checked (through the generated code) for each individual case. Indirect recursions are discovered by the linker/locator.


C267

Funcdef requires ANSI-style prototype:

A function was invoked with parameters but the declaration specifies an empty parameter list. The prototype should be completed with the parameter types in order to give the compiler the opportunity to pass parameters in registers and have the calling mechanism consistent over the application.


C268

Bad taskdef (taskid/priority/using):

The task declaration is incorrect.


C271

Misplaced 'asm/endasm' control:

The asm and endasm statements may not be nested. Endasm requires that an asm block be opened by a previous asm statement.

Symptoms:

Cause:

Example

#pragma asm
.
.
.
assembler instruction(s)
.
.
.
#pragma endasm


C272

'asm' requires SRC control to be active:

The use of asm and endasm in a source file requires that the file be compiled using the SRC directive. The compiler then generates an assembly source file which may then be assembled with A51.


C273

'asm/endasm' not allowed in include file:

The use of asm and endasm is not permitted within include files. For debug reasons executable code should be avoided in include files anyway.


C274

Absolute specifier illegal:

The absolute address specification is not allowed on bit objects, functions, and function locals. The address must conform to the memory space of the object. For example, the following declaration is invalid because the range of the indirectly addressable data space is 0x00 to 0xFF.

Symptoms:

Cause:

Example

idata int _at_ 0x1000;


C275

Expression with possibly no effect:

The compiler detected an expression which does not generate code.

Symptoms:

Cause:

Example

void test (void)  {
  int i1, i2, i3;
  i1, i2, i3;         /* dead expression */
  i1 << 3;            /* result is not used */
}


C276

Constant in condition expression:

The compiler detected a conditional expression with a constant value. In most cases this is a typing mistake.

Symptoms:

Cause:

Example

void test (void)  {
  int i1, i2, i3;
  if (i1 = 1)  i2 = 3;   /* const assigned with = */
  while (i3 = 2);        /* const assigned with = */
}


C277

Different mspaces to pointer:

A typedef declaration has a conflict of the memory spaces.

Symptoms:

Cause:

Example

typedef char xdata XCC;    /* mspace xdata     */
typedef XCC idata PICC;    /* mspace collision */


C278

Constant too big:

This error occurs when a floating-point argument lies outside of the valid range for 32-bit floating values. The numeric range of the 32-bit IEEE values is: ±1.175494E-38 to ±3.402823E+38.


C279

Multiple initialization:

An attempt has been made to initialize some object more than once.


C280

Unreferenced symbol/label:

This message identifies a symbol or label which has been defined but not used.


C300

Unterminated comment:

This message occurs when a comment does not have a closing delimiter (*/).


C301

Identifier expected:

The syntax of a preprocessor directive expects an identifier.


C302

Misused # operator:

This message occurs if the stringize operator '#' is not followed by an identifier.


C303

Formal argument expected:

This message occurs if the stringize operator '#' is not followed by an identifier representing a formal parameter name of the macro currently being defined.


C304

Bad macro parameter list:

The macro parameter list does not represent a brace enclosed, comma separated list of identifiers.


C305

Unterminated string/char constant:

A string or character constant is invalid. Typically, this error is encountered if the closing quote is missing.


C306

Unterminated macro call:

The end of the input file was reached while the preprocessor was collecting and expanding actual parameters of a macro call.


C307

Macro 'name': parameter count mismatch:

The number of actual parameters in a macro call does not match the number of parameters of the macro definition. This error indicates that too few parameters were specified. Excess parameters are ignored.


C308

Invalid integer constant expression:

The numerical expression of an if/elif directive contains a syntax error.


C309

Bad or missing file name:

The filename argument in an include directive is invalid or missing.


C310

Conditionals too nested(20):

The source file contains too many nested directives for conditional compilation. The maximum nesting level allowed is 20.


C311

Misplaced elif/else control, Misplaced endif control:

The directives elif, else, and endif are legal only within an if, ifdef, or ifndef directive.


C312

Can't remove predefined macro 'name':

The directives elif, else, and endif are legal only within an if, ifdef, or ifndef directive.


C313

Can't remove predefined macro 'name':

An attempt was made to remove a predefined macro. Existing macros may be deleted using the #undef directive. Predefined macros cannot be removed. The compiler recognizes the following predefined macros:

_ _C51_ __ _DATE_ __ _FILE_ _

_ _MODEL_ _
_ _LINE_ __ _STDC_ __ _TIME_ _


C314

Bad # directive syntax:

In a preprocessor directive, the character '#' must be followed by either a newline character or the name of a preprocessor command (for example, if/define/ifdef, ...).


C315

Unknown # directive 'name':

The name of the preprocessor directive is not known to the compiler.


C316

Unterminated conditionals:

The number of endifs does not match the number of if or ifdefs after the end of the input file.


C317

Macro 'name': invalid redefinition:

A predefined macro cannot be redefined or removed. The compiler recognizes the following predefined macros:

_ _C51_ __ _DATE_ __ _FILE_ __ _MODEL_ _
_ _LINE_ __ _STDC_ __ _TIME_ _


C318

Can't open file 'filename':

The given file could not be opened.


C319

'File' is not a disk file:

The given file is not a disk file. Files other than disk files are not legal for compilation.


C320

User_error_text:

This error number is reserved for errors introduced with the #error directive of the preprocessor. The #error directive causes the user error text to come up with error 320 which counts like some other error and prevents the compiler from generating code.


C321

Missing <character>:

In the filename argument of an include directive, the closing character is missing. For example: #include <stdio.h>


C322

Unknown identifier:

The identifier in an #if directive line is undefined (evaluates to FALSE).


C323

Newline expected, extra characters found:

A #directive line is correct but contains extra non commented characters.

Symptoms:

Cause:

Example

#include <stdio.h>  foo


C324

Preprocessor token expected:

A preprocessor token was expected but a newline character was found in input. For example: #line where the arguments to the #line directive are missing.


C325

Duplicate formal parameter 'name':

A formal parameter of a macro may be define only once.


C326

Macro body cannot start or end with '##':

The concat operator ('##') cannot be the first or last token of a macro body.


C327

Macro 'macroname': more than 50 parameters:

The number of parameters per macro is limited to 50.


L1

UNRESOLVED EXTERNAL SYMBOL:

The specified external symbol, requested in the specified module, has no corresponding PUBLIC symbol in any of the input files.

Symptoms:

Cause:

Example

UNRESOLVED EXTERNAL SYMBOL
SYMBOL: external-name
MODULE: filename (modulename)


L2

REFERENCE MADE TO UNRESOLVED EXTERNAL:

The specified unresolved external symbol is referenced at the specified code address.

Symptoms:

Cause:

Example

SYMBOL:  external-name
MODULE:  filename (modulename)
ADDRESS: code-address


L3

ASSIGNED ADDRESS NOT COMPATIBLE WITH ALIGNMEN:

The address specified for the segment is not compatible with the alignment of the segment declaration.

Symptoms:

Cause:

Example

SEGMENT: segment–name


L4

DATA SPACE MEMORY OVERLAP:

The specified area of the on-chip data RAM is occupied by more than one segment.

Symptoms:

Cause:

Example

FROM: byte.bit address
TO:   byte.bit address


L5

CODE SPACE MEMORY OVERLAP:

The specified area of the code memory is occupied by more than one segment.

Symptoms:

Cause:

Example

FROM: byte address
TO:   byte address


L6

XDATA SPACE MEMORY OVERLAP:

The specified area of the external data memory is occupied by more than one segment.

Symptoms:

Cause:

Example

FROM: byte address
TO:   byte address


L7

MODULE NAME NOT UNIQUE:

The specified module name is used for more than one module. The specified module name is not processed.

Symptoms:

Cause:

Example

MODULE: filename (modulename)


L8

MODULE NAME EXPLICITLY REQUESTED FROM ANOTHER FILE:

The specified module name is requested in the invocation line of another file that has not yet been processed. The specified module name is not processed.

Symptoms:

Cause:

Example

MODULE: filename (modulename)


L9

EMPTY ABSOLUTE SEGMENT:

The specified module contains an empty absolute segment. This segment is not located and may be overlapped with another segment without any additional message.

Symptoms:

Cause:

Example

MODULE: filename (modulename)


L10

CANNOT DETERMINE ROOT SEGMENT:

The Linker/Locator has recognized the C51 compiler or PL/M-51 input files and tries to process a flow analysis. However it is impossible to determine the root segment. This error occurs if the main program is called by an assembly module. In this case the available references (calls) must be modified with the OVERLAY directive.


L11

CANNOT FIND SEGMENT OR FUNCTION NAME:

A segment or function name defined in the OVERLAY directive cannot be found in the object modules.

Symptoms:

Cause:

Example

NAME: overlay-control-name


L12

NO REFERENCE BETWEEN SEGMENTS:

An attempt was made to delete a reference or call between two non-existent functions or segments, with the OVERLAY directive.

Symptoms:

Cause:

Example

SEGMENT1: segment-name
SEGMENT2: segment-name


L13

RECURSIVE CALL TO SEGMENT:

The specified segment is called recursively from CALLER specified segments. Recursive calls are not allowed in C51 and PL/M-51 programs.

Symptoms:

Cause:

Example

SEGMENT: segment-name
CALLER:  segment-name


L14

INCOMPATIBLE MEMORY MODEL:

The specified module is not compiled in the same memory model as the former compiled modules. The memory model of the improper module is showed by MODEL.

Symptoms:

Cause:

Example

MODULE: filename (modulename)
MODEL:  memory model


L15

MULTIPLE CALL TO SEGMENT:

The specified segment is called from two levels, CALLER1, and CALLER2; e.g., main and interrupt program. This has the same effect as a recursive call and may thus lead to the overwriting of parameters or data.

Symptoms:

Cause:

Example

SEGMENT: segment-name
CALLER1: segment-name
CALLER2: segment-name


L16

UNCALLED SEGMENT, IGNORED FOR OVERLAY PROCESS:

This warning occurs when functions which were not previously called are contained in a program (e.g., for test purposes). The function specified is excluded from the overlay process in this case. It is possible that the program then occupies more memory as during a call of the specified segment.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L17

INTERRUPT FUNCTION IN BANKS NOT ALLOWED:

The specified C function is an interrupt function (a C51 function) that was specified to be located in a code bank. Interrupt functions cannot be located in a code bank

Symptoms:

Cause:

Example

SYMBOL: function-name
SPACE:  code-bank


L101

SEGMENT COMBINATION ERROR:

The attributes of the specified partial segment in the specified module cannot be combined with the attributes of the previous defined partial segments of the same name. The partial segment is ignored.

Symptoms:

Cause:

Example

SEGMENT: segment-name
MODULE:  filename (modulename)


L102

EXTERNAL ATTRIBUTE MISMATCH:

The attributes of the specified external symbol in the specified module do not match the attributes of the previously defined external symbols. The specified symbol is ignored.

Symptoms:

Cause:

Example

SYMBOL: external-name
MODULE: filename (modulename)


L103

EXTERNAL ATTRIBUTE DO NOT MATCH PUBLIC:

The attributes of the specified public symbols in the specified module do not match the attributes of the previous defined external symbols. The specified symbol is ignored.

Symptoms:

Cause:

Example

SYMBOL: public-name
MODULE: filename (modulename)


L104

MULTIPLE PUBLIC DEFINITIONS:

The specified public symbol in the specified module has already been defined in a previously processed file.

Symptoms:

Cause:

Example

SYMBOL: public-name
MODULE: filename (modulename)


L105

PUBLIC REFERS TO IGNORED SEGMENT:

The specified public symbol is defined in the specified segment. It cannot be processed on account of an error. The public symbol is therefore ignored.

Symptoms:

Cause:

Example

SYMBOL: public-name
SEGMENT: segment-name


L106

SEGMENT OVERFLOW:

The specified segment is longer than 64 KByte and cannot be processed.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L107

ADDRESS SPACE OVERFLOW:

The specified segment cannot be located at the specified address space. The segment is ignored.

Symptoms:

Cause:

Example

SPACE: space-name
SEGMENT: segment-name


L108

SEGMENT IN LOCATING CONTROL CANNOT BE ALLOCATED:

The specified segment in the invocation line cannot be processed on account of its attributes.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L109

EMPTY RELOCATABLE SEGMENT:

The specified segment after combination has a zero size. The specified segment is ignored.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L110

CANNOT FIND SEGMENT:

The specified segment is contained in the invocation line but cannot be found in an input module. The specified segment is ignored.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L111

SPECIFIED BIT ADDRESS NOT ON BYTE BOUNDARY:

The specified segment contained in the BIT directive is a DATA segment. The specified BIT address however is not on a byte boundary. The segment is ignored.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L112

SEGMENT TYPE NOT LEGAL FOR COMMAND:

The specified segment cannot be processed because it does not have a legal type.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L114

SEGMENT DOES NOT FIT:

The specified segment cannot be located at the base address in the specified address space because of its length. The segment is ignored.

Symptoms:

Cause:

Example

SPACE:   space-name
SEGMENT: segment-name
BASE:    base-address
LENGTH:  segment-length


L115

INPAGE SEGMENT IS GREATER THAN 256 BYTES:

The specified segment with the attributes PAGE or INPAGE is greater than 256 bytes. The segment is ignored.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L116

INBLOCK SEGMENT IS GREATER THAN 2048 BYTES:

The specified segment with the attribute INBLOCK is greater than 2048 bytes. The segment is ignored.

Symptoms:

Cause:

Example

SEGMENT: segment-name


L117

BIT ADDRESSABLE SEGMENT IS GREATER THAN 16 BYTES:

The specified bit or data segment that was declared with the BITADDRESSABLE attribute is larger than 16 bytes. The segment is not ignored.


L118

REFERENCE MADE TO ERRONEOUS EXTERNAL:

The specified external symbol that was erroneously processed, is referenced in the specified code address.

Symptoms:

Cause:

Example

SYMBOL:  symbol-name
MODULE:  filename (modulename)
ADDRESS: code-address


L119

REFERENCE MADE TO ERRONEOUS SEGMENT:

The specified segment processed with an error, is referenced in the specified code address.

Symptoms:

Cause:

Example

SYMBOL:  symbol-name
MODULE:  filename (modulename)
ADDRESS: code-address


L120

CONTENT BELONGS TO ERRONEOUS SEGMENT:

A specified segment that was erroneously processed, is referenced at a specific code address. The segment contents are not available.

Output:

Symptoms:

Cause:

Resotution:


L121

IMPROPER FIXUP:

After evaluation of absolute fixups, an address is not accessible. The improper address along with the specific module name, partial segment, and segment address are displayed. The fixup command is not processed.

Linker Output:

MODULE: filename (modulename)
SEGMENT: segment-name
OFFSET: segment-address

Symptoms:
In a C source file I have declared a pdata variable called foo. I wish to access this variable in an assembly module, and I have written the following code to do this:

EXTRN XDATA (foo)
...
MOV R0, #foo
MOV @R0, A

Cause:
This is because when using the EXTRN directive you have specified the variable as xdata. This is correct since pdata variables are stored in xdata, however the assembler assigns a 16-bit address to the variable, but only an 8-bit address exists for the pdata variable.

Resotution:

Move the lower byte of the 16-bit address of the variable into R0. The upper byte will be present on P2 during the memory access.

Example

MOV R0, #LOW (foo)


L122

CANNOT FIND MODULE:

The module specified in the invocation line cannot be found in the input file.

Symptoms:

Cause:

Example

MODULE: filename (modulename)


L123

ABSOLUTE DATA/IDATA SEGMENT DOES NOT FIT:

An absolute DATA or IDATA segment contained in the specified module is not permissible due to a conflict with the value specified with the RAMSIZE directive. The absolute segment cannot be located in the area which was output.

Symptoms:

Cause:

Example

MODULE: filename (modulename)
FROM:   byte address
TO:     byte address


L124

BANK SWITCH MODULE INCORRECT:

This error message is issued when the bank switch module file (L51_BANK.OBJ) contains invalid information or is not specified.