8.3 Messages 1000 Thru 1499

(1003) nested "if" directives too deep (Assembler)

The nesting of the assembler's IF … ENDIF directive is too deep. Reduce the number of IF directives that appear inside other IF directives.

(1015) missing “*” specification in chipinfo file “*” at line * (Driver)

This attribute was expected to appear at least once but was not defined for this chip.

(1016) missing argument* to “*” specification in chipinfo file “*” at line * (Driver)

This value of this attribute is blank in the chip configuration file.

(1017) extraneous argument* to “*” specification in chipinfo file “*” at line * (Driver)

There are too many attributes for the listed specification in the chip configuration file.

(1018) illegal number of “*” specification* (* found; * expected) in chipinfo file “*” at line * 
 (Driver)

This attribute was expected to appear a certain number of times; but it did not appear for this chip.

(1019) duplicate “*” specification in chipinfo file “*” at line * (Driver)

This attribute can only be defined once, but has been defined more than once for this chip.

(1020) unknown attribute “*” in chipinfo file “*” at line * (Driver)

The chip configuration file contains an attribute that is not understood by this version of the compiler. Has the chip configuration file or the driver been replaced with an equivalent component from another version of this compiler?

(1021) syntax error reading “*” value in chipinfo file “*” at line * (Driver)

The chip configuration file incorrectly defines the specified value for this device. If you are modifying this file yourself, take care and refer to the comments at the beginning of this file for a description on what type of values are expected here.

(1022) syntax error reading “*” range in chipinfo file “*” at line * (Driver)

The chip configuration file incorrectly defines the specified range for this device. If you are modifying this file yourself, take care and refer to the comments at the beginning of this file for a description on what type of values are expected here.

(1024) syntax error in chipinfo file “*” at line * (Driver)

The chip configuration file contains a syntax error at the line specified.

(1025) unknown architecture in chipinfo file “*” at line * (Driver)

The attribute at the line indicated defines an architecture that is unknown to this compiler.

(1026) missing architecture in chipinfo file “*” at line * (Assembler)

The chipinfo file has a device section without an ARCH values. The architecture of the device must be specified. Contact Microchip Technical Support if the chipinfo file has not been modified.

(1027) activation was successful (Driver)

The compiler was successfully activated.

(1028) activation was not successful - error code (*) (Driver)

The compiler did not activated successfully.

(1029) compiler not installed correctly - error code (*) (Driver)

This compiler has failed to find any activation information and cannot proceed to execute. The compiler can have been installed incorrectly or incompletely. The error code quoted can help diagnose the reason for this failure. You can be asked for this failure code if contacting Microchip for assistance with this problem.

(1030) Hexmate - Intel HEX editing utility (Build 1.%i) (Hexmate)

Indicating the version number of the Hexmate being executed.

(1031) USAGE: * [input1.HEX] [input2.HEX]... [inputN.HEX] [options] (Hexmate)

The suggested usage of Hexmate.

(1032) use –HELP=<option> for usage of these command line options (Hexmate)

More detailed information is available for a specific option by passing that option to the -HELP option.

(1033) available command-line options: (Hexmate)

This is a simple heading that appears before the list of available options for this application.

(1034) type “*” for available options (Hexmate)

It looks like you need help. This advisory suggests how to get more information about the options available to this application or the usage of these options.

(1035) bad argument count (*) (Parser)

The number of arguments to a function is unreasonable. This is an internal compiler error. Contact Microchip Technical Support with details.

(1036) bad “*” optional header length (0x* expected) (Cromwell)

The length of the optional header in this COFF file was of an incorrect length.

(1037) short read on * (Cromwell)

When reading the type of data indicated in this message, it terminated before reaching its specified length.

(1038) string table length too short (Cromwell)

The specified length of the COFF string table is less than the minimum.

(1039) inconsistent symbol count (Cromwell)

The number of symbols in the symbol table has exceeded the number indicated in the COFF header.

(1040) bad : record 0x*, 0x* (Cromwell)

A record of the type specified failed to match its own value.

(1041) short record (Cromwell)

While reading a file, one of the file’s records ended short of its specified length.

(1042) unknown * record type 0x* (Cromwell)

The type indicator of this record did not match any valid types for this file format.

(1043) unknown optional header (Cromwell)

When reading this Microchip COFF file, the optional header within the file header was of an incorrect length.

(1044) end of file encountered (Cromwell, Linker)

The end of the file was found while more data was expected. Has this input file been truncated?

(1045) short read on block of * bytes (Cromwell)

A while reading a block of byte data from a UBROF record, the block ended before the expected length.

(1046) short string read (Cromwell)

A while reading a string from a UBROF record, the string ended before the specified length.

(1047) bad type byte for UBROF file (Cromwell)

This UBROF file did not begin with the correct record.

(1048) bad time/date stamp (Cromwell)

This UBROF file has a bad time/date stamp.

(1049) wrong CRC on 0x* bytes; should be * (Cromwell)

An end record has a mismatching CRC value in this UBROF file.

(1050) bad date in 0x52 record (Cromwell)

A debug record has a bad date component in this UBROF file.

(1051) bad date in 0x01 record (Cromwell)

A start of program record or segment record has a bad date component in this UBROF file.

(1052) unknown record type (Cromwell)

A record type could not be determined when reading this UBROF file.

(1053) additional RAM ranges larger than bank size (Driver)

A block of additional RAM being requested exceeds the size of a bank. Try breaking the block into multiple ranges that do not cross bank boundaries.

(1054) additional RAM range out of bounds (Driver)

The RAM memory range as defined through custom RAM configuration is out of range.

(1055) RAM range out of bounds (*) (Driver)

The RAM memory range as defined in the chip configuration file or through custom configuration is out of range.

(1056) unknown chip architecture (Driver)

The compiler is attempting to compile for a device of an architecture that is either unsupported or disabled.

(1058) assertion (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1059) rewrite loop (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1081) static initialization of persistent variable “*” (Parser, Code Generator)

A persistent variable has been assigned an initial value. This is somewhat contradictory as the initial value will be assigned to the variable during execution of the compiler’s startup code; however, the persistent qualifier requests that this variable shall be unchanged by the compiler’s startup code.

(1082) size of initialized array element is zero (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1088) function pointer “*” is used but never assigned a value (Code Generator)

A function call involving a function pointer was made, but the pointer was never assigned a target address, for example:
void (*fp)(int);
fp(23);     /* oops -- what function does fp point to? */

(1089) recursive function call to “*” (Code Generator)

A recursive call to the specified function has been found. The call can be direct or indirect (using function pointers) and can be either a function calling itself, or calling another function whose call graph includes the function under consideration.

(1090) variable “*” is not used (Code Generator)

This variable is declared but has not been used by the program. Consider removing it from the program.

(1091) main function “*” not defined (Code Generator)

The main function has not been defined. Every C program must have a function called main().

(1094) bad derived type (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1095) bad call to typeSub() (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1096) type should be unqualified (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1097) unknown type string “*” (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1098) conflicting declarations for variable “*” (*:*) (Parser, Code Generator)

Differing type information has been detected in the declarations for a variable, or between a declaration and the definition of a variable, for example:
extern long int test;
int test;    /* oops -- which is right? int or long int ? */

(1104) unqualified error (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1118) bad string “*” in getexpr(J) (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1119) bad string “*” in getexpr(LRN) (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1121) expression error (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1137) match() error: * (Code Generator)

This is an internal compiler error. Contact Microchip Technical Support with details.

(1157) W register must be W9 (Assembler)

The working register required here has to be W9, but an other working register was selected.

(1159) W register must be W11 (Assembler)

The working register required here has to be W11, but an other working register was selected.

(1178) the “*” option has been removed and has no effect (Driver)

This option no longer exists in this version of the compiler and has been ignored. Use the compiler’s --help option or refer to the manual to find a replacement option.

(1179) interrupt level for function “*” cannot exceed * (Code Generator)

The interrupt level for the function specified is too high. Each interrupt function is assigned a unique interrupt level. This level is considered when analyzing the call graph and reentrantly called functions. If using the interrupt_level pragma, check the value specified.

(1180) directory “*” does not exist (Driver)

The directory specified in the setup option does not exist. Create the directory and try again.

(1182) near variables must be global or static (Code Generator)

A variable qualified as near must also be qualified with static or made global. An auto variable cannot be qualified as near.

(1183) invalid version number (Activation)

During activation, no matching version number was found on the Microchip activation server database for the serial number specified.

(1184) activation limit reached (Activation)

The number of activations of the serial number specified has exceeded the maximum number allowed for the license.

(1185) invalid serial number (Activation)

During activation, no matching serial number was found on the Microchip activation server database.

(1186) license has expired (Driver)

The time-limited license for this compiler has expired.

(1187) invalid activation request ( Driver)

The compiler has not been correctly activated.

(1188) network error * (Activation)

The compiler activation software was unable to connect to the Microchip activation server via the network.

(1190) FAE license only - not for use in commercial applications (Driver)

Indicates that this compiler has been activated with an FAE license. This license does not permit the product to be used for the development of commercial applications.

(1191) licensed for educational use only (Driver)

Indicates that this compiler has been activated with an education license. The educational license is only available to educational facilities and does not permit the product to be used for the development of commercial applications.

(1192) licensed for evaluation purposes only (Driver)

Indicates that this compiler has been activated with an evaluation license.

(1193) this license will expire on * (Driver)

The compiler has been installed as a time-limited trial. This trial will end on the date specified.

(1195) invalid syntax for “*” option (Driver)

A command line option that accepts additional parameters was given inappropriate data or insufficient data. For example, an option can expect two parameters with both being integers. Passing a string as one of these parameters or supplying only one parameter could result in this error.

(1198) too many “*” specifications; * maximum (Hexmate)

This option has been specified too many times. If possible, try performing these operations over several command lines.

(1199) compiler has not been activated (Driver)

The trial period for this compiler has expired. The compiler is now inoperable until activated with a valid serial number. Contact Microchip to purchase this software and obtain a serial number.

(1200) Found %0*lXh at address *h (Hexmate)

The code sequence specified in a -FIND option has been found at this address.

(1201) all FIND/REPLACE code specifications must be of equal width (Hexmate)

All find, replace and mask attributes in this option must be of the same byte width. Check the parameters supplied to this option. For example, finding 1234h (2 bytes) masked with FFh (1 byte) results in an error; but, masking with 00FFh (2 bytes) works.

(1202) unknown format requested in -FORMAT: * (Hexmate)

An unknown or unsupported INHX format has been requested. Refer to documentation for supported INHX formats.

(1203) unpaired nibble in * value will be truncated (Hexmate)

Data to this option was not entered as whole bytes. Perhaps the data was incomplete or a leading zero was omitted. For example, the value Fh contains only four bits of significant data and is not a whole byte. The value 0Fh contains eight bits of significant data and is a whole byte.

(1204) * value must be between 1 and * bytes long (Hexmate)

An illegal length of data was given to this option. The value provided to this option exceeds the maximum or minimum bounds required by this option.

(1205) using the configuration file *; you can override this with the environment variable HTC_XML (Driver)

This is the compiler configuration file selected during compiler setup. This can be changed via the HTC_XML environment variable. This file is used to determine where the compiler has been installed.

(1207) some of the command line options you are using are now obsolete (Driver)

Some of the command line options passed to the driver have now been discontinued in this version of the compiler; however, during a grace period these old options will still be processed by the driver.

(1208) use –help option or refer to the user manual for option details (Driver)

An obsolete option was detected. Use --help or refer to the manual to find a replacement option that will not result in this advisory message.

(1209) An old MPLAB tool suite plug-in was detected. (Driver)

The options passed to the driver resemble those that the Microchip MPLAB 8 IDE would pass to a previous version of this compiler. Some of these options are now obsolete – however, they were still interpreted. It is recommended that you install an updated Microchip options plug-in for the IDE.

(1210) Visit the Microchip website (www.microchip.com) for a possible upgrade (Driver)

Visit our website to see if an upgrade is available to address the issue(s) listed in the previous compiler message. Navigate to the MPLAB XC8 C Compiler page and look for a version upgrade downloadable file. If your version is current, contact Microchip Technical Support for further information.

(1212) Found * (%0*lXh) at address *h (Hexmate)

The code sequence specified in a -FIND option has been found at this address.

(1213) duplicate ARCH for * in chipinfo file at line * (Assembler, Driver)

The chipinfo file has a device section with multiple ARCH values. Only one ARCH value is allowed. If you have not manually edited the chip info file, contact Microchip Technical Support with details.

(1218) can’t create cross reference file * (Assembler)

The assembler attempted to create a cross reference file; but it could not be created. Check that the file’s path name is correct.

(1228) unable to locate installation directory (Driver)

The compiler cannot determine the directory where it has been installed.

(1230) dereferencing uninitialized pointer “*” (Code Generator)

A pointer that has not yet been assigned a value has been dereferenced. This can result in erroneous behavior at runtime.

(1235) unknown keyword * (Driver)

The token contained in the USB descriptor file was not recognized.

(1236) invalid argument to *: * (Driver)

An option that can take additional parameters was given an invalid parameter value. Check the usage of the option or the syntax or range of the expected parameter.

(1237) endpoint 0 is pre-defined (Driver)

An attempt has been made to define endpoint 0 in a USB file.

(1238) FNALIGN failure on * ( Linker)

Two functions have their auto/parameter blocks aligned using the FNALIGN directive, but one function calls the other, which implies that must not be aligned. This will occur if a function pointer is assigned the address of each function, but one function calls the other. For example:
int one(int a) { return a; }
int two(int a) { return two(a)+2; }  /* ! */
int (*ip)(int);
ip = one;
ip(23);
ip = two;      /* ip references one and two; two calls one */
ip(67);

(1239) pointer * has no valid targets (Code Generator)

A function call involving a function pointer was made, but the pointer was never assigned a target address, for example:
void (*fp)(int);
fp(23);     /* oops -- what function does fp point to? */

(1240) unknown algorithm type (%i) (Driver)

The error file specified after the -Efile or -E+file options could not be opened. Check to ensure that the file or directory is valid and that has read only access.

(1241) bad start address in * (Driver)

The start of range address for the --CHECKSUM option could not be read. This value must be a hexadecimal number.

(1242) bad end address in * (Driver)

The end of range address for the --CHECKSUM option could not be read. This value must be a hexadecimal number.

(1243) bad destination address in * (Driver)

The destination address for the --CHECKSUM option could not be read. This value must be a hexadecimal number.

(1245) value greater than zero required for * (Hexmate)

The align operand to the Hexmate -FIND option must be positive.

(1246) no RAM defined for variable placement (Code Generator)

No memory has been specified to cover the banked RAM memory.

(1247) no access RAM defined for variable placement (Code Generator)

No memory has been specified to cover the access bank memory.

(1248) symbol (*) encountered with undefined type size (Code Generator)

The code generator was asked to position a variable, but the size of the variable is not known. This is an internal compiler error. Contact Microchip Technical Support with details.

(1250) could not find space (* byte*) for variable * (Code Generator)

The code generator could not find space in the banked RAM for the variable specified.

(1253) could not find space (* byte*) for auto/param block 
 (Code Generator)

The code generator could not find space in RAM for the psect that holds auto and parameter variables.

(1254) could not find space (* byte*) for data block (Code Generator)

The code generator could not find space in RAM for the data psect that holds initialized variables.

(1255) conflicting paths for output directory (Driver)

The compiler has been given contradictory paths for the output directory via any of the -O or --OUTDIR options, for example:
--outdir=../../   -o../main.HEX

(1256) undefined symbol “*” treated as HEX constant (Assembler)

A token which could either be interpreted as a symbol or a hexadecimal value does not match any previously defined symbol and so will be interpreted as the latter. Use a leading zero to avoid the ambiguity, or use an alternate radix specifier such as 0x. For example:
MOV  a, F7h  ; is this the symbol F7h, or the HEX number 0xF7?

(1257) local variable “*” is used but never given a value (Code Generator)

An auto variable has been defined and used in an expression, but it has not been assigned a value in the C code before its first use. Auto variables are not cleared on startup and their initial value is undefined. For example:
int main(void) {
    double src, out;
    out = sin(src);   /* oops -- what value was in src? */

(1258) possible stack overflow when calling function “*” (Code Generator)

The call tree analysis by the code generator indicates that the hardware stack can overflow. This should be treated as a guide only. Interrupts, the assembler optimizer and the program structure can affect the stack usage. The stack usage is based on the C program and does not include any call tree derived from assembly code.

(1259) can’t optimize for both speed and space (Driver)

The driver has been given contradictory options of compile for speed and compile for space, for example:
--opt=speed,space

(1260) macro “*” redefined (Assembler)

More than one definition for a macro with the same name has been encountered, for example:
MACRO fin
    ret
ENDM
MACRO fin   ; oops -- was this meant to be a different macro?
    reti
ENDM

(1261) string constant required (Assembler)

A string argument is required with the DS or DSU directive, for example:
DS ONE     ; oops -- did you mean DS "ONE"?

(1262) object “*” lies outside available * space (Code Generator)

An absolute variable was positioned at a memory location which is not within the memory defined for the target device, for example:
int data __at(0x800);     /* oops -- is this the correct address? */

(1264) unsafe pointer conversion (Code Generator)

A pointer to one kind of structure has been converted to another kind of structure and the structures do not have a similar definition, for example:
struct ONE {
    unsigned a;
    long b;          /* ! */
} one;
struct TWO {
    unsigned a;
    unsigned b;      /* ! */
} two;
struct ONE * oneptr;
oneptr = & two;    /* oops -- was ONE meant to be same struct as TWO? */

(1267) fixup overflow referencing * into * bytes at 0x* (Linker)

See error message 1356 for more information.

(1268) fixup overflow storing 0x* in * bytes at * (Linker)

See error message 1356 for more information.

(1273) Omniscient Code Generation not available in Free mode (Driver)

This message advises that advanced features of the compiler are not be enabled in this Free mode compiler.

(1275) the qualifier “*” is only applicable to functions (Parser)

A qualifier which only makes sense when used in a function definition has been used with a variable definition.
interrupt int dacResult;  /* oops --
the interrupt qualifier can only be used with functions */

(1276) buffer overflow in DWARF location list (Cromwell)

A buffer associated with the ELF/DWARF debug file has overflowed. Contact Microchip Technical Support with details.

(1278) omitting “*” which does not have a location (Cromwell)

A variable has no storage location listed and will be omitted from the debug output. Contact Microchip Technical Support with details.

(1284) malformed mapfile while generating summary: CLASS expected but not found 
 (Driver)

The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.

(1285) malformed mapfile while generating summary: no name at position * (Driver)

The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.

(1286) malformed mapfile while generating summary: no link address at position * ( Driver)

The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.

(1287) malformed mapfile while generating summary: no load address at position *
 (Driver)

The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.

(1288) malformed mapfile while generating summary: no length at position * (Driver)

The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.

(1289) line range limit exceeded, possibly affecting ability to debug code (Cromwell)

A C statement has produced assembly code output whose length exceeds a preset limit. This means that debug information produced by CROMWELL may not be accurate. This warning does not indicate any potential code failure.

(1290) buffer overflow in DWARF debugging information entry (Cromwell)

A buffer associated with the ELF/DWARF debug file has overflowed. Contact Microchip Technical Support with details.

(1291) bad ELF string table index (Cromwell)

An ELF file passed to CROMWELL is malformed and cannot be used.

(1292) malformed define in .SDB file * (Cromwell)

The named SDB file passed to CROMWELL is malformed and cannot be used.

(1293) couldn’t find type for “*” in DWARF debugging information entry (Cromwell)

The type of symbol could not be determined from the SDB file passed to CROMWELL. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.

(1294) there is only one day left until this license expires (Driver)

The compiler is running as a demo and will be unable to run in PRO mode after the evaluation license has expired in less than one day’s time. After expiration, the compiler can be operated in Free mode indefinitely, but will produce a larger output binary.

(1295) there are * days left until this license will expire (Driver)

The compiler is running as a demo and will be unable to run in PRO mode after the evaluation license has expired in the indicated time. After expiration, the compiler can be operated in Free mode indefinitely, but will produce a larger output binary.

(1296) source file “*” conflicts with “*” (Driver)

The compiler has encountered more than one source file with the same base name. This can only be the case if the files are contained in different directories. As the compiler and IDEs based the names of intermediate files on the base names of source files, and intermediate files are always stored in the same location, this situation is illegal. Ensure the base name of all source files are unique.

(1297) option * not available in Free mode (Driver)

Some options are not available when the compiler operates in Free mode. The options disabled are typically related to how the compiler is executed, e.g., --getoption and --setoption, and do not control compiler features related to code generation.

(1298) use of * outside macros is illegal (Assembler)

Some assembler directives, e.g., EXITM, can only be used inside macro definitions.

(1299) non-standard modifier “*” - use “*” instead (Parser)

A printf placeholder modifier has been used which is non-standard. Use the indicated modifier instead. For example, the standard hh modifier should be used in preference to b to indicate that the value should be printed as a char type.

(1300) maximum number of program classes reached; some classes may be excluded from debugging information (Cromwell)

CROMWELL is passed a list of class names on the command line. If the number of class names passed in is too large, not all will be used and there is the possibility that debugging information will be inaccurate.

(1301) invalid ELF section header; skipping (Cromwell)

CROMWELL found an invalid section in an ELF section header. This section will be skipped.

(1302) could not find valid ELF output extension for this device (Cromwell)

The extension could not be for the target device family.

(1303) invalid variable location detected: * - * (Cromwell)

A symbol location could not be determined from the SDB file.

(1304) unknown register name: “*” (Cromwell)

The location for the indicated symbol in the SDB file was a register, but the register name was not recognized.

(1305) inconsistent storage class for variable: “*” (Cromwell)

The storage class for the indicated symbol in the SDB file was not recognized.

(1306) inconsistent size (* vs *) for variable: “*” (Cromwell)

The size of the symbol indicated in the SDB file does not match the size of its type.

(1307) psect * truncated to * bytes (Driver)

The psect representing either the stack or heap could not be made as large as requested and will be truncated to fit the available memory space.

(1308) missing/conflicting interrupts sub-option; defaulting to “*” (Driver)

The suboptions to the --INTERRUPT option are missing or malformed, for example:
--INTERRUPTS=single,multi

Oops, did you mean single-vector or multi-vector interrupts?

(1309) ignoring invalid runtime * sub-option (*) using default (Driver)

The indicated suboption to the --RUNTIME option is malformed, for example:
--RUNTIME=default,speed:0y1234

Oops, that should be 0x1234.

(1310) specified speed (*Hz) exceeds max operating frequency (*Hz); defaulting to *Hz 
 (Driver)

The frequency specified to the perform suboption to --RUNTIME option is too large for the selected device.
--RUNTIME=default,speed:0xffffffff

Oops, that value is too large.

(1311) missing configuration setting for config word *; using default (Driver)

The configuration settings for the indicated word have not be supplied in the source code and a default value will be used.

(1312) conflicting runtime perform sub-option and configuration word settings; assuming *Hz (Driver)

The configuration settings and the value specified with the perform suboption of the --RUNTIME options conflict and a default frequency has been selected.

(1313) * sub-options (“*”) ignored (Driver)

The argument to a suboption is not required and will be ignored.
--OUTPUT=intel:8

Oops, the :8 is not required

(1314) illegal action in memory allocation (Code Generator)

This is an internal error. Contact Microchip Technical Support with details.

(1315) undefined or empty class used to link psect * (Linker)

The linker was asked to place a psect within the range of addresses specified by a class, but the class was either never defined, or contains no memory ranges.

(1316) attribute “*” ignored (Parser)

An attribute has been encountered that is valid, but which is not implemented by the parser. It will be ignored by the parser and the attribute will have no effect. Contact Microchip Technical Support with details.

(1317) missing argument to attribute “*” (Parser)

An attribute has been encountered that requires an argument, but this is not present. Contact Microchip Technical Support with details.

(1318) invalid argument to attribute “*” (Parser)

An argument to an attribute has been encountered, but it is malformed. Contact Microchip Technical Support with details.

(1319) invalid type “*” for attribute “*” (Parser)

This indicated a bad option passed to the parser. Contact Microchip Technical Support with details.

(1320) attribute “*” already exists (Parser)

This indicated the same attribute option being passed to the parser more than once. Contact Microchip Technical Support with details.

(1321) bad attribute -T option “%s” (Parser)

The attribute option passed to the parser is malformed. Contact Microchip Technical Support with details.

(1322) unknown qualifier “%s” given to -T (Parser)

The qualifier specified in an attribute option is not known. Contact Microchip Technical Support with details.

(1323) attribute expected (Parser)

The __attribute__ directive was used but did not specify an attribute type.
int rv (int a) __attribute__(())  /* oops -- what is the attribute? */

(1324) qualifier “*” ignored (Parser)

Some qualifiers are valid, but cannot be implemented on some compilers or target devices. This warning indicates that the qualifier will be ignored.

(1339) operand must be a %u-bit wide %s value (Assembler)

The instruction operand must have the maximum width and signedness indicated.
moviw [100]FSR1  ; oops - the index value is too large
addlw low(01h)

(1342) whitespace after “\” (Preprocessor)

Whitespace characters have been found between a backslash and newline characters and will be ignored.

(1343) hexfile data at address 0x* (0x*) overwritten with 0x* (Objtohex)

The indicated address is about to be overwritten by additional data. This would indicate more than one section of code contributing to the same address.

(1346) can’t find 0x* words for psect “*” in segment “*” (largest unused contiguous range 0x%lX) (Linker)

See also message (491). The new form of message also indicates the largest free block that the linker could find. Unless there is a single space large enough to accommodate the psect, the linker will issue this message. Often when there is banking or paging involved the largest free space is much smaller than the total amount of space remaining,

(1347) can’t find 0x* words (0x* withtotal) for psect “*” in segment “*” (largest unused contiguous range 0x%lX) (Linker)

See also message (593). The new form of message also indicates the largest free block that the linker could find. Unless there is a single space large enough to accommodate the psect, the linker will issue this message. Often when there is banking or paging involved the largest free space is much smaller than the total amount of space remaining,

(1348) enum tag “*” redefined (from *:*) (Parser)

More than one enum tag with the same name has been defined, The previous definition is indicated in the message.
enum VALS { ONE=1, TWO, THREE };
enum VALS { NINE=9, TEN };  /* oops -- is VALS the right tag name? */

(1349) initialization of absolute variable "*" in RAM is not supported (Code Generator)

An absolute variable, one defined using __at(address), cannot be assigned an initial value when it is defined. Place an assignment to the variable at an appropriate location in your program.
int foobar __at(0x20) = 0x55;  /* oops --
 you cannot assign a value to an absolute variable */

(1350) pointer operands to “-” must reference the same array (Code Generator)

If two addresses are subtracted, the addresses must be of the same object to be ANSI compliant.
int * ip;
int fred, buf[20];
ip = &buf[0] - &fred;  /* oops --
 second operand must be an address of a "buf" element */

(1352) truncation of operand value (0x*) to * bits (Assembler)

The operand to an assembler instruction was too large and was truncated.
movlw  0x321  ; oops -- is this the right value?

(1354) ignoring configuration setting for unimplemented word * (Driver)

A Configuration Word setting was specified for a Word that does not exist on the target device.
__CONFIG(3, 0x1234);  /* config word 3 does not exist on an 18C801 */

(1355) in-line delay argument too large (Code Generator)

The in-line delay sequence _delay has been used, but the number of instruction cycles requested is too large. Use this routine multiple times to achieve the desired delay length.
#include <xc.h>
int main(void) {
    delay(0x400000); /* oops -- cannot delay by this number of cycles */
}

(1356) fixup overflow referencing * * (0x*) into * byte* at 0x*/0x* -> 0x* (*** */0x*) (Linker)

’Fixup’ is the process conducted by the linker of replacing symbolic references to operands with an absolute value. This takes place after positioning the psects (program sections or blocks) into the available memory. ‘Fixup overflow’ is when a symbol’s value is too large to fit within the assembler instruction. For example, if an assembler instruction has an 8-bit field to hold an address and the linker determines that the symbol used to represent this address has the value 0x110, then clearly this value cannot be encoded into the instruction.

Fixup errors are often caused by hand-written assembly code. Common mistakes that trigger these errors include failing to mask a full, banked data address in file register instructions, or failing to mask the destination address in jump or call instructions. If this error is triggered by assembly code generated from C source, then it is often that constructs like switch() statements have generated a block of assembly too large for jump instructions to span. Adjusting the default linker options can also causes such errors.

To identify these errors, follow these steps.

  • Perform a debug build (in MPLAB X IDE select Debug > Discrete Debugger Operation > Build for Debugging; alternatively, on the command line use the 
-D__DEBUG option).
  • Open the relevant assembler list file (ensure the MPLAB X IDE project properties has XC8 Compiler > Preprocessing and Messaging > Generate the ASM listing file enabled; alternatively, on the command line, use the -Wa,-a option).
  • Find the instruction at the address quoted in the error message.

Consider the following error message.

main.c: 4: (1356)(linker) fixup overflow referencing psect bssBANK1 (0x100) into 1 byte at 0x7FF0/0x1 -> 0x7FF0 (main.obj 23/0x0)

The file being linked was main.obj. This tells you the assembly list file in which you should be looking is main.lst. The location of the instruction at fault is 0x7FF0 (You can also tell from this message that the instruction is expecting a 1 byte quantity—this size is rounded to the nearest byte—but the value was determined to be 0x100).

In the assembly list file, search for the address specified in the error message.

61  007FF0  6F00      movwf   _foobar,b       ;#

and to confirm, look for the symbol referenced in the assembler instruction at this address in the symbol table at the bottom of the same file.

Symbol Table                    Tue Oct 28 11:06:37 2014
_foobar 0100
In this example, the hand-written PIC18 movwf instruction causing the problem takes an 8-bit offset into a bank of memory, but clearly the address 0x100 exceeds this size. The instruction should have been written as:
MOVWF		BANKMASK(_foo)
which masks out the top bits of the address containing the bank information. Alternatively, the linker can be instructed to ignore fixup overflows, or to issue a warning rather than an error in such situations. See 6.1.31 Fixupoverflow Linker Option for more information, as the use of this option may compromise the detection of genuine errors.

If the assembler instruction that caused this error was generated by the compiler, in the assembler list file look back up the file from the instruction at fault to determine which C statement has generated this instruction. You will then need to examine the C code for possible errors.

(1357) fixup overflow storing 0x* in * byte* at 0x*/0x* -> 0x* (*** */0x*) (Linker)

See message (1356).

(1358) no space for * temps (*) (Code Generator)

The code generator was unable to find a space large enough to hold the temporary variables (scratch variables) for this program.

(1359) no space for * parameters (Code Generator)

The code generator was unable to find a space large enough to hold the parameter variables for a particular function.

(1360) no space for auto/param * (Code Generator)

The code generator was unable to find a space large enough to hold the auto variables for a particular function. Some parameters passed in registers can need to be allocated space in this auto area as well.

(1361) syntax error in configuration argument (Parser)

The argument to #pragma config was malformed.
#pragma config WDT     /* oops -- is WDT on or off? */

(1362) configuration setting *=* redefined (Code Generator)

The same config pragma setting have been issued more than once with different values.
#pragma config WDT=OFF
#pragma config WDT=ON     /* oops -- is WDT on or off? */

(1363) unknown configuration setting (* = *) used (Driver)

The configuration value and setting is not known for the target device. The use of an unknown configuration register number may also trigger this message.
#pragma config WDR=ON     /* oops -- did you mean WDT? */
#pragma config CONFIG1L=0x46 /* oops -- no 1L register on a 18F4520 */

(1364) can’t open configuration registers data file * (Driver)

The file containing value configuration settings could not be found.

(1365) missing argument to pragma “varlocate” (Parser)

The argument to #pragma varlocate was malformed.
#pragma varlocate    /* oops -- what do you want to locate & where? */

(1366) syntax error in pragma “varlocate” (Parser)

The argument to #pragma varlocate was malformed.
#pragma varlocate fred     /* oops -- which bank for fred? */

(1367) end of file in _asm (Parser)

An end-of-file marker was encountered inside a _asm _endasm block.

(1368) assembler message: * (Assembler)

Displayed is an assembler advisory message produced by the MESSG directive contained in the assembler source.

(1369) can’t open proc file * (Driver)

The proc file for the selected device could not be opened.

(1370) peripheral library support is not available for the * (Driver)

The peripheral library is not available for the selected device.

(1371) float type can’t be bigger than double type; double has been changed to * bits
 (Driver)

Use of the -fshort-double options has result in the size of the double type being smaller than that of the float type. This is not permitted by the C Standard. The double type size has been increased to be that indicated.

(1372) interrupt level cannot be greater than * (Code Generator)

The specific interrupt_level is too high for the device selected.
#pragma interrupt_level 4
// oops - there aren't that many interrupts on this device

(1374) the compiler feature “*” is no longer supported; * (Driver)

The feature indicated is no longer supported by the compiler.

(1375) multiple interrupt functions (* and *) defined for device with only one interrupt vector (Code Generator)

The named functions have both been qualified interrupt, but the target device only supports one interrupt vector and hence one interrupt function.
interrupt void isr_lo(void) {
// ...
}
interrupt void isr_hi(void) {   // oops, cannot define two ISRs
// ...
}

(1376) initial value (*) too large for bitfield width (*) (Code Generator)

A structure with bit-fields has been defined an initialized with values. The value indicated it too large to fit in the corresponding bit-field width.
struct {
unsigned flag :1;
unsigned mode :3;
} foobar = { 1, 100 };   // oops, 100 is too large for a 3 bit object

(1377) no suitable strategy for this switch (Code Generator)

The compiler was unable to determine the switch strategy to use to encode a C switch statement based on the code and your selection using the #pragma switch directive. You can need to choose a different strategy.

(1378) syntax error in pragma “*” (Parser)

The arguments to the indicated pragma are not valid.
#pragma addrqual ingore  // oops -- did you mean ignore?

(1379) no suitable strategy for this switch (Code Generator)

The compiler encodes switch() statements according to one of a number of strategies. The specific number and values of the case values, and the switch expression, as well as the switch pragma determine the strategy chosen. This error indicates that no strategy was available to encode the switch() statement. Contact Microchip support with program details.

(1380) unable to use switch strategy “*” (Code Generator)

The compiler encodes switch() statements according to one of a number of strategies. The specific number and values of the case values, and the switch expression, as well as the switch pragma, determine the strategy chosen. This error indicates that the strategy that was requested cannot be used to encode the switch() statement. Contact Microchip support with program details.

(1381) invalid case label range (Parser)

The values supplied for the case range are not correct. They must form an ascending range and be integer constants.
case 0 ... -2:  // oops -- do you mean -2 ... 0  ?

(1385) * “*” is deprecated (declared at *:*) (Parser)

Code is using a variable or function that was marked as being deprecated using an attribute.
char __attribute__((deprecated)) foobar;
foobar = 9;     // oops -- this variable is near end-of-life

(1386) unable to determine the semantics of the configuration setting “*” for register “*” 
 (Parser, Code Generator)

The numerical value supplied to a configuration bit setting has no direct association setting specified in the data sheet. The compiler will attempt to honor your request, but check your device data sheet.
#pragma config OSC=11
// oops -- there is no direct association for that value on an 18F2520
// either use OSC=3 or OSC=RC

(1387) in-line delay argument must be constant (Code Generator)

The _delay in-line function can only take a constant expression as its argument.
int delay_val = 99;
_delay(delay_val);   // oops, argument must be a constant expression

(1388) configuration setting/register of “*” with 0x* will be truncated by 0x* 
 (Parser, Code Generator)

A Configuration bit has been programmed with a value that is either too large for the setting, or is not one of the prescribed values.
#pragma config WDTPS=138  // oops -- do you mean 128?

(1389) attempt to reprogram configuration * “*” with * (is *) (Parser, Code Generator)

A Configuration bit that was already programmed has been programmed again with a conflicting setting to the original.
#pragma config WDT=ON
#pragma config WDT=OFF  // oops -- watchdog on or off?

(1390) identifier specifies insignificant characters beyond maximum identifier length
 (Parser)

An identifier that has been used is so long that it exceeds the set identifier length. This can mean that long identifiers cannot be correctly identified and the code will fail. The maximum identifier length can be adjusted using the -N option.
int theValueOfThePortAfterTheModeBitsHaveBeenSet;
// oops, make your symbol shorter or increase the maximum
// identifier length

(1391) constant object size of * exceeds the maximum of * for this chip (Code Generator)

The const object defined is too large for the target device.
const int array[200] = { ... };  // oops -- not on a Baseline part!

(1392) function “*” is called indirectly from both mainline and interrupt code
 (Code Generator)

A function has been called by main-line (non-interrupt) and interrupt code. If this warning is issued, it highlights that such code currently violates a compiler limitation for the selected device.

(1393) possible hardware stack overflow detected; estimated stack depth: * 
 (Code Generator)

The compiler has detected that the call graph for a program could be using more stack space that allocated on the target device. If this is the case, the code can fail. The compiler can only make assumption regarding the stack usage, when interrupts are involved and these lead to a worst-case estimate of stack usage. Confirm the function call nesting if this warning is issued.

(1394) attempting to create memory range ( * - * ) larger than page size * (Driver)

The compiler driver has detected that the memory settings include a program memory “page” that is larger than the page size for the device. This would mostly likely be the case if the --ROM option is used to change the default memory settings. Consult your device data sheet to determine the page size of the device you are using and to ensure that any contiguous memory range you specify using the --ROM option has a boundary that corresponds to the device page boundaries.
--ROM=100-1fff

The above might need to be paged. If the page size is 800h, the above could specified as

--ROM=100-7ff,800-fff,1000-17ff,1800-1fff

(1395) notable code sequence candidate suitable for compiler validation suite detected (*)
 (Code Generator)

The compiler has in-built checks that can determine if combinations of internal code templates have been encountered. Where unique combinations are uncovered when compiling code, this message is issued. This message is not an error or warning and its presence does not indicate possible code failure, but if you are willing to participate, the code you are compiling can be sent to Support to assist with the compiler testing process.

(1396) “*” positioned in the * memory region (0x* - 0x*) reserved by the compiler 
 (Code Generator)

Some memory regions are reserved for use by the compiler. These regions are not normally used to allocate variables defined in your code. However, by making variables absolute, it is possible to place variables in these regions and avoid errors that would normally be issued by the linker. Absolute variables can be placed at any location, even on top of other objects. This warning from the code generator indicates that an absolute has been detected that will be located at memory that the compiler will be reserving. You must locate the absolute variable at a different location. This message will commonly be issued when placing variables in the common memory space.
char shared __at(0x7);   // oops, this memory is required by the compiler

(1397) unable to implement non-stack call to “*”; possible hardware stack overflow 
 (Code Generator)

The compiler must encode a C function call without using a call assembly instruction and the hardware stack (i.e., use a lookup table), but is unable to. A call instruction might be required if the function is called indirectly via a pointer, but if the hardware stack is already full, an additional call will cause a stack overflow.

(1401) eeprom qualified variables can’t be accessed from both interrupt and mainline code (Code Generator)

All eeprom variables are accessed via routines that are not reentrant. Code might fail if an attempt is made to access eeprom-qualified variables from interrupt and main-line code. Avoid accessing eeprom variables in interrupt functions.

(1402) a pointer to eeprom can’t also point to other data types (Code Generator)

A pointer cannot have targets in both the EEPROM space and ordinary data space.

(1403) pragma “*” ignored (Parser)

The pragma you have specified has no effect and will be ignored by the compiler. This message can only be issued in C18 compatibility mode.
#pragma varlocate "mySection" fred  // oops -- not accepted

(1404) unsupported: * (Parser)

The unsupported __attribute__ has been used to indicate that some code feature is not supported.

The message printed will indicate the feature that is not supported and which should be avoided.

(1405) storage class specifier “*” ignored (Parser)

The storage class you have specified is not required and will be ignored by the compiler. This message can only be issued in C18 compatibility mode.
int procInput(auto int inValue)  // oops -- no need for auto
{ ...

(1406) auto eeprom variables are not supported (Code Generator)

Variables qualified as eeprom cannot be auto. You can define static local objects qualified as eeprom, if required.
int main(void) {
eeprom int mode;  // oops -- make this static or global

(1407) bit eeprom variables are not supported (Code Generator)

Variables qualified as eeprom cannot have type bit.
eeprom bit myEEbit;    // oops -- you cannot define bits in EEPROM

(1408) ignoring initialization of far variables (Code Generator)

Variables qualified as far cannot be assigned an initial value. Assign the value later in the code.
far int chan = 0x1234; // oops -- you cannot assign a value here

(1409) warning number used with pragma “warning” is invalid (Parser)

The message number used with the warning pragma is below zero or larger than the highest message number available.
#pragma warning disable 1316 13350   // oops -- possibly number 1335?

(1410) can’t assign the result of an invalid function pointer (Code Generator)

The compiler allows some functions to be called via a constant cast to be a function pointer, but not all. The address specified is not valid for this device.
foobar += ((int (*)(int))0x0)(77);
// oops -- you cannot call a function with a NULL pointer

(1411) Additional ROM range out of bounds (Driver)

Program memory specified with the -mrom option is outside of the on-chip, or external, memory range supported by this device.
-mrom=default,+2000-2ffff

Oops -- memory too high, should that be 2fff?

(1412) missing argument to pragma “warning disable” (Parser)

Following the #pragma warning disable should be a comma-separated list of message numbers to disable.
#pragma warning disable  // oops -- what messages are to be disabled?

Try something like the following.

#pragma warning disable 1362

(1413) pointer comparisons involving address of “*”, positioned at address 0x0, may be invalid (Code Generator)

An absolute object placed at address 0 has had its address taken. By definition, this is a NULL pointer and code which checks for NULL (i.e., checks to see if the address is valid) can fail.
int foobar __at(0x00);
int  * ip;
int main(void)
{
    ip = &foobar;  // oops -- 0 is not a valid address

(1414) option * is defunct and has no effect (Driver)

The option used is now longer supported. It will be ignored.
xc8 --chip=18f452 --cp=24 main.c

Oops -- the --cp option is no longer required.

(1415) argument to “merge” psect flag must be 0 or 1 (Assembler)

This psect flag must be assigned a 0 or 1.
PSECT myTxt,class=CODE,merge=true  ; oops -- I think you mean merge=1

(1416) psect flag “merge” redefined (Assembler)

A psect with a name seen before specifies a different merge flag value to that previously seen.
psect mytext,class=CODE,merge=1
; and later
psect mytext,class=CODE,merge=0
; Oops, can mytext be merged or not?

(1417) argument to “split” psect flag must be 0 or 1 (Assembler)

This psect flag must be assigned a 0 or 1.
psect mytext,class=CODE,split=5

Oops, the split flag argument must be 0 or 1.

(1418) Attempt to read “control” qualified object which is Write-Only (Code Generator)

An attempt was made to read a write-only register.
state = OPTION;  // oops -- you cannot read this register

(1419) using the configuration file *; you can override this with the environment variable XC_XML (Driver)

This is the compiler configuration file that is selected during compiler setup. This can be changed via the XC_XML environment variable. This file is used to determine where the compiler has been installed. See message 1205.

(1420) ignoring suboption “*” (Driver)

The suboption you have specified is not valid in this implementation and will be ignored.
--RUNTIME=default,+ramtest

oops -- what is ramtest?

(1421) the qualifier __xdata is not supported by this architecture (Parser)

The qualifier you have specified is not valid in this implementation and will be ignored.
__xdata int coeff[2];  // that has no meaning for this target

(1422) the qualifier __ydata is not supported by this architecture (Parser)

The qualifier you have specified is not valid in this implementation and will be ignored.
__ydata int coeff[2];  // that has no meaning for this target

(1423) case ranges are not supported (Driver)

The use of GCC-style numerical ranges in case values does not conform to the CCI Standard. Use individual case labels and values to conform.
switch(input) {
case 0 ... 5:    // oops -- ranges of values are not supported
    low();

(1424) short long integer types are not supported (Parser)

The use of the short long type does not conform to the CCI Standard. Use the corresponding long type instead.
short long typeMod;    // oops -- not a valid type for CCI

(1425) __pack qualifier only applies to structures and structure members (Parser)

The qualifier you have specified only makes sense when used with structures or structure members. It will be ignored.
__pack int c;  // oops -- there aren’t inter-member spaces to pack in an int

(1426) 24-bit floating point types are not supported; * have been changed to 32-bits
 (Driver)

Floating-point types must be 32-bits wide to conform to the CCI Standard. These types will be compiled as 32-bit wide quantities.
-fshort-double=24

oops -- you cannot set this double size

(1427) machine-dependent path specified in name of included file; use -I instead
 (Preprocessor)

To conform to the CCI Standard, header file specifications must not contain directory separators.
#inlcude <inc\lcd.h>    // oops -- do not indicate directories here

Remove the path information and use the -I option to indicate this, for example:

#include <lcd.h>

and issue the -Ilcd option.

(1428) “*” is not supported; this feature will be ignored (Driver)

The specified option is not supported and will have no effect on compilation.
xc8-cc -mcpu=18f4520 --html main.c

Oops, --html is not a valid option.

(1429) attribute “*” is not understood by the compiler; this attribute will be ignored
 (Parser)

The indicated attribute you have used is not valid with this implementation. It will be ignored.
int x __attribute__ ((deprecate)) = 0;

oops -- did you mean deprecated?

(1430) section redefined from “*” to “*” (Parser)

You have attempted to place an object in more than one section.
int __section("foo") __section("bar") myvar;  // oops -- which section should it be in?

(1431) the __section specifier is applicable only to variable and function definitions at file-scope (Parser)

You cannot attempt to locate local objects using the __section() specifier.
int main(void) {
int __section("myData") counter;  // oops -- you cannot specify a section for autos

(1432) “*” is not a valid section name (Parser)

The section name specified with __section() is not a valid section name. The section name must conform to normal C identifier rules.
int __section("28data") counter;  // oops -- name cannot start with digits

(1433) function “*” could not be inlined (Assembler)

The specified function could not be made in-line. The function will called in the usual way.
int inline getData(int port)   // sorry -- no luck inlining this
{   //...

(1434) missing name after pragma “intrinsic” (Parser)

The intrinsic pragma needs a function name. This pragma is not needed in most situations. If you mean to in-line a function, see the inline keyword or pragma.
#pragma intrinsic    // oops -- what function is intrinsically called?

(1435) variable “*” is incompatible with other objects in section “*” (Code Generator)

You cannot place variables that have differing startup initializations into the same psect. That is, variables that are cleared at startup and variables that are assigned an initial non-zero value must be in different psects. Similarly, bit objects cannot be mixed with byte objects, like char or int.
int __section("myData") input;   // okay
int __section("myData") output;  // okay
int __section("myData") lvl = 0x12;  // oops -- not with uninitialized
bit __section("myData") mode;    // oops again -- no bits with bytes
// each different object to their own new section

(1436) “*” is not a valid nibble; use hexadecimal digits only (Parser)

When using __IDLOC(), the argument must only consist of hexadecimal digits with no radix specifiers or other characters. Any character which is not a hexadecimal digit will be programmed as a 0 in the corresponding location.
__IDLOC(0x51);  // oops -- you cannot use the 0x radix modifier

(1437) CMF error * (Cromwell, Linker)

The CMF file being read by Cromwell or the linker is invalid. Unless you have modified or manually generated this file, this is an internal error. Contact Microchip Technical Support with details.

(1438) pragma “*” options ignored (Parser)

You have used unsupported options with a pragma. The options will be ignored.
#pragma inline=forced  // oops -- no options allowed with this pragma

(1439) message: * (Parser)

This is a programmer generated message; there is a pragma directive causing this advisory to be printed. This is only printed when using IAR C extensions.
#pragma message "this is a message from your programmer"

(1440) big-endian storage is not supported by this compiler (Parser)

You have specified the __big_endian IAR extension for a variable. The big-endian storage format is not supported by this compiler. Remove the specification and ensure that other code does not rely on this endianism.
__big_endian int  volume;  // oops -- this won’t be big endian

(1441) use __at() instead of '@' and ensure the address is applicable (Parser)

You have used the @ address specifier when using the IAR C extensions. Any address specified is unlikely to be correct on a new architecture. Review the address in conjunction with your device data sheet. To prevent this warning from appearing again, use the reviewed address with the __at() specifier instead.

(1442) type used in definition is incomplete (Parser)

When defining objects, the type must be complete. If you attempt to define an object using an incomplete type, this message is issued.
typedef struct foo foo_t;
foo_t x;   // oops -- you cannot use foo_t until it is fully defined
struct foo {
int i;
};

(1443) unknown --EXT sub-option “*” (Driver)

The suboption to the --EXT option is not valid.
xc8 --chip=18f8585 x.c --ext=arm --ext=cci

Oops -- valid choices are iar, cci and xc8

(1444) respecified C extension from “*” to “*” (Driver)

The --EXT option has been used more than once, with conflicting arguments. The last use of the option will dictate the C extensions accepted by the compiler.
xc8 --chip=18f8585 x.c --ext=iar --ext=cci

Oops -- which C extension do you mean?

(1445) #advisory: * (Preprocessor)

This is a programmer generated message; there is a directive causing this advisory to be printed.
#advisory "please listen to this good advice"

(1446) #info: * (Preprocessor)

This is a programmer generated message; there is a directive causing this advisory to be printed. It is identical to #advisory messages (1445).
#info "the following is for your information only"

(1447) extra -L option (-L*) ignored (Preprocessor)

This error relates to a duplicate -L option being passed to the preprocessor. Unless you are explicitly running this application, consider this an internal error. Contact Microchip Technical Support with details.

(1448) no dependency file type specified with -L option (Preprocessor)

This error relates to a malformed -L option being passed to the preprocessor. Unless you are explicitly running this application, consider this an internal error. Contact Microchip Technical Support with details.

(1449) unknown dependency file type (*) (Preprocessor)

This error relates to a unknown dependency file format being passed to the preprocessor. Unless you are explicitly running this application, consider this an internal error. Contact Microchip Technical Support with details.

(1450) invalid --*-spaces argument (*) (Cromwell)

The option passed to Cromwell does not relate to a valid memory space. The space arguments must be a valid number that represents the space.
--data-spaces=a

Oops — a is not a valid data space number.

(1451) no * spaces have been defined (Cromwell)

Cromwell must be passed information that indicates the type for each numbered memory space. This is done via the --code-spaces and --data-spaces options. Unless you are explicitly running this application, consider this an internal error. Contact Microchip Technical Support with details.

(1452) one or more spaces are defined as data and code (Cromwell)

The options passed to Cromwell indicate memory space is both in the code and data space. Unless you are explicitly running this application, consider this an internal error. Contact Microchip Technical Support with details.
--code-space=1,2  --data-space=1

Oops — is space 1 code or data?

(1453) stack size specified for non-existent or unused * software stack (Driver)

The -mstack option has been used, specifying a maximum size for some or all of the available stacks, but the compiler cannot see that the indicated stack has been used by the program. For example, space might have been requested for an interrupt stack, but there was no corresponding interrupt function found in the code.
-mstack=reentrant:20:20:auto

Oops, you have asked for two interrupt stacks, but the compiler cannot see both interrupt function definitions.

(1454) stack size specified (*) is greater than available (*) (Driver)

The -mstack option has been used to specify the maximum sizes for each stack, but the total amount of memory requested exceeds the amount of memory available.
-mstack=software:1000:1000:20000

Oops, that is too much stack space for a small device.

(1455) unrecognized stack size “*” in “*” (Driver)

The -mstack option has been used to specify the maximum sizes for each stack, but one or more of the sizes are not a valid value. Use only decimal values in this option, or the token auto, for a default size.
-mstack=software:30:all:default

Oops, only use decimal numbers or auto.

(1456) too many stack size specifiers (Driver)

Too many software stack maximum sizes have been specified in the -mstack option. The maximum stack sizes are optional. If used, specify one size for each interrupt and one for main-line code.
-mstack=reentrant:20:20:auto

Oops, too many sizes for a device with only one interrupt.

(1457) local variable “*” cannot be made absolute (Code Generator)

You cannot specify the address of any local variable, whether it be an auto, parameter, or static local object.
int pushState(int a) {
int cnt __at(0x100); // oops -- you cannot specify an address ...

(1458) Omniscient Code Generation not available in Standard mode (Driver)

This message warns you that not all optimizations are enabled in the Standard operating mode.

(1459) peripheral library support is missing for the * (Driver)

The peripheral libraries do not have code present for the device you have selected. Disable the option that links in the peripheral library.

(1460) function-level profiling is not available for the selected chip (Driver)

Function profiling is only available for PIC18 or enhanced mid-range devices. If you are not using such a device, do not attempt to use function profiling.

(1461) insufficient h/w stack to profile function “*” (Code Generator)

Function profiling requires a level of hardware stack. The entire stack has been used by this program so not all functions can be profiled. The indicated function will not have profiling code embedded into it, and it will not contribute to the profiling information displayed by MPLAB X IDE.

(1462) reentrant data stack model option conflicts with stack management option and will be ignored (Code Generator)

The managed stack option allows conversion of function calls that would exceed the hardware stack depth to calls that will use a lookup table. This option cannot be enabled if the reentrant function model is also enabled. If you attempt to use both the managed stack and reentrant function model options, this message will be generated. Code will be compiled with the stack management option disabled. Either disable the reentrant function model or the managed stack option.

(1463) reentrant data stack model not supported on this device; using compiled stack for data (Code Generator)

The target device does not support reentrant functions. The program will be compiled so that stack-based data is placed on a compiled stack.

(1464) number of arguments passed to function “*” does not match function's prototype 
 (Code Generator)

A function was called with arguments, but the declaration of the function had an empty parameter list (as opposed to a parameter list of void).
int test();    // oops--this should define the parameters
...
test(12, input);

(1465) the stack frame size for function “*” (* bytes) has exceeded the maximum allowable (* bytes) (Code Generator)

The compiler has been able to determine that the software stack requirements for the named function’s auto, parameter, and temporary variables exceed the maximum allowable. The limits are 31 for enhanced mid-range devices and 127 for PIC18 devices. Reduce the size or number of these variables. Consider static local objects instead of auto objects.
reentrant int addOffset(int offset) {
int report[400];    // oops--this will never fit on the software stack

(1466) registers * unavailable for code generation of this expression (Code Generator)

The compiler has been unable to generate code for this statement. This is essentially a “can’t generate code” error message (message 712), but the reason for this inability to compile relates to there not being enough registers available. See message 712 for suggested workarounds.

(1467) pointer used for writes includes read-only target “*” (Code Generator)

A pointer to a non-const-qualified type is being used to write a value, but the compiler knows that this pointer has targets (the first of which is indicated) that have been qualified const. This could lead to code failure or other error messages being generated.
void keepTotal(char * cp) {
    *cp += total;
}
char c;
const char name[] = "blender";
keepTotal(&c);
keepTotal(&name[2]);  // oops--will write a read-only object

(1468) unknown ELF/DWARF specification (*) in --output option (Driver)

The ELF suboption uses flags that are unknown.
—output=elf:3

Oops, there is no elf flag of 3.

This elf suboption and its flags are usually issued by the MPLAB X IDE plugin. Contact Microchip Technical Support with details of the compiler and IDE if this error is issued.

(1469) function specifier “reentrant/software” used with “*” ignored (Code Generator)

The reentrant (or software) specifier was used with a function (indicated) that cannot be encoded to use the software stack. The specifier will be ignored and the function will use the compiled stack.
reentrant int main(void) // oops--main cannot be reentrant
{ ...

(1470) trigraph sequence “??*” replaced (Preprocessor)

The preprocessor has replaced a trigraph sequence in the source code. Ensure you intended to use a trigraph sequence.
char label[] = “What??!”;  // you do know that’s a trigraph
// sequence, right?

(1471) indirect function call via a NULL pointer ignored (Code Generator)

The compiler has detected a function pointer with no valid target other than NULL. That pointer has been used to call a function. The call will not be made.
int (*fp)(int, int);
result = fp(8,10);  // oops--this pointer has not been initialized

(1472) --CODEOFFSET option ignored: * (Driver)

The compiler is ignoring an invocation of the -mcodeoffset option. The printed description will indicate whether the option is being ignored because the compiler has seen this option previously or the compilation mode does not support its use.

(1474) read-only target “*” may be indirectly written via pointer (Code Generator)

This is the same as message 1467, but for situations where an error is required. The compiler has encountered a pointer that is used to write, and one or more of the pointer’s targets are read-only.
const char c = ‘x’;
char * cp = &c; // will produce warning 359 about address assignment
*cp = 0x44;     // oops--you ignored the warning above, now you are
// actually going to write using the pointer?

(1478) initial value for “*” differs to that in *:* (Code Generator)

The named object has been defined more than once and its initial values do not agree. Remember that uninitialized objects of static storage duration are implicitly initialized with the value zero (for all object elements or members, where appropriate).
char myArray[5] = { 0 };
// elsewhere
char myArray[5] = {0,2,4,6,8};  // oops--previously initialized
// with zeros, now with different values

(1479) EEPROM data not supported by this device (Parser)

The eeprom qualifier was used but there is no EEPROM on the target device. Any instances of this qualifier will be ignored.
eeprom int serialNo; 	     // oops--no EEPROM on this device

(1480) initial value(s) not supplied in braces; zero assumed (Code Generator)

The assignment operator was used to indicate that the object was to be initialized, but no values were found in the braces. The object will be initialized with the value(s) 0.
int xy_map[3][3] = { };   // oops--did you mean to supply values?

(1481) call from non-reentrant function, “*”, to “*” might corrupt parameters
 (Code Generator)

If several functions can be called indirectly by the same function pointer, they are called ‘buddy’ functions, and the parameters to buddy functions are aligned in memory. This allows the parameters to be loaded without knowing exactly which function was called by the pointer (as is often the case). However, this means that the buddy functions cannot directly or indirectly call each other.
// fpa can call any of these, so they are all buddies
int (*fpa[])(int) = { one, two, three };
int one(int x) {
    return three(x+1);  // oops--one() cannot call buddy three()
}

(1482) absolute object * overlaps * (Linker)

The reservation for an absolute object has been found to overlap with the memory reserved by another absolute object.
unsigned char nfo[6] __at(0x80);
unsigned char nfo2[6] __at(0x7b);  //oops--this overlaps nfo

(1483) __pack qualifier ignored (Parser)

The __pack qualifier has no affect on auto or static local structures and has been ignored.
int setInput(void) {
    __pack struct {       //oops--this will not be packed
        unsigned x, y;
    } inputData;
...

(1484) the branch errata option is turned on and a BRW instruction was detected
 (Assembler)

The use of this instruction may cause code failure with the selected device. Check the published errata for your device to see if this restriction is applicable for your device revision. If so, remove this instruction from hand-written assembly code.
btfsc status,2
brw  next      ;oops--this instruction cannot be safely used
call  update

(1485) * mode is not available with the current license and other modes are not permitted by the NOFALLBACK option (Driver)

This compiler’s license does not allow the requested compiler operating mode. Since the --nofallback option is enabled, the compiler has produced this error and will not fall back to a lower operating mode. If you believe that you are entitled to use the compiler in the requested mode, this error indicates that your compiler might not be activated correctly.

(1486) size of pointer cannot be determined during preprocessing. Using default size *
 (Preprocessor)

The preprocessor cannot determine the size of pointer type. Do not use the sizeof operator in expressions that need to be evaluated by the preprocessor.
#if sizeof(int *) == 3   // oops - you can't take the size of a pointer type
#define MAX 40
#endif

(1488) the stack frame size for function “*” may have exceeded the maximum allowable (* bytes) (Code Generator)

This message is emitted in the situation where the indicated function's software-stack data has exceeded the theoretical maximum allowable size. Data outside this stack space will only be accessible by some instructions that could attempt to access it. In some situations the excess data can be retrieved, your code will work as expected, and you can ignore this warning. This is likely if the function calls a reentrant function that returns a large object, like a structure, on the stack. At other times, instructions that are unable to access this data will, in addition to this warning, trigger an error message at the assembly stage of the build process, and you will need to look at reducing the amount of stack data defined by the function.

(1489) unterminated IF directive at end of psect * (Assembler)

The assembler has reached the end of the named psect and not seen the terminating ENDIF directive associated with the last IF or ELSIF directive previously encountered.
psect mytext,class=CODE,reloc=2
movlw 20h
IF TEST_ONLY
    movlw 00h
    movwf _mode,c  ; oops--where does the IF end?
psect nexttext,class=CODE,reloc=2

(1490) ENDIF not inside an IF directive (Assembler)

The assembler has encountered an ENDIF directive that does not have any corresponding IF or ELSIF directive.
psect mytext,class=CODE,reloc=2
movlw 20h
IF TEST_ONLY
    movlw 00h
ENDIF
ENDIF	; oops--what does this terminate?

(1491) runtime sub-option “*” is not available for this device (Driver)

A specified suboption to the --RUNTIME option is not available for the selected device.
xc8 --CHIP=MCP19114 --RUNTIME=+osccal main.c

Oops, the osccal suboption is not available for this device.

(1492) using updated 32-bit floating-point libraries; improved accuracy might increase code size (Code Generator)

This advisory message ensures you are aware of the changes in 32-bit floating-point library code operation that might lead to an increase in code size.

(1493) updated 32-bit floating-point routines might trigger “can't find space” messages appearing after updating to this release; consider using the smaller 24-bit floating-point types (Linker)

This advisory message ensures you are aware of the changes in 32-bit floating-point library code operation, which might lead to the Can’t Find Space error message that has been issued.

(1494) invalid argument to normalize32 (Assembler)

The NORMALIZE32 operator has been used on an operand that is not a literal constant.
NORMALIZE(_foobar)  ; oops--that must be a literal constant operand

(1495) ADDFSR/SUBFSR instruction argument must be 0-3 (Assembler)

The operand to this instruction must be a literal constant and in the range 0 to 3, inclusive.
addfsr 1, 6  ; oops--the offset must be between 0 to 3

(1496) arithmetic on pointer to void yields Undefined Behavior (Code Generator)

Performing operations on pointers requires the size of the pointed-to object, which is not known in the case of generic (void *) pointers.
void * vp;
vp++;   // oops—how can this be incremented without knowing what it points to?

(1497) more than one *interrupt function defined (Code Generator)

Only one interrupt function of the same priority can be defined.
void interrupt lo_isr(void) {  // oops — was this meant to be a low_priority interrupt?
  …
}
void interrupt hi_isr(void) {
  …
}

(1498) pointer (*) in expression may have no targets (Code Generator)

A pointer that contains NULL has been dereferenced. Assign the pointer a valid address before doing so.
char * cp, c;
c = *cp;	// oops —what is cp pointing to?

(1499) only decimal floating-point constants can be suffixed “f” or “F”

The floating-point constant suffix has been used with an integer value.
float myFloat = 100f*3.2;  // oops — is ‘100f’ mean to be a hex or floating-point value?