home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
AMIGA PD 1
/
AMIGA-PD-1.iso
/
Programme_zum_Heft
/
Programmieren
/
Kurztests
/
DiceC
/
doc
/
errors.doc
< prev
next >
Wrap
Text File
|
1994-02-01
|
21KB
|
721 lines
ERRORS.DOC
***********************************************************************
* *
* *
* DCPP ERROR MESSAGES *
* *
* *
***********************************************************************
"#undef: no symbol specified"
You have an #undef directive which specifies no symbol to undef
"maximum number of macro arguments exceeded (256)"
Macros cannot deal with more then 256 arguments (think that's
enough!)
"Expected comma"
"Expected ')'"
Generally occurs when parsing macros, a comma or closing paren
was expected.
"Macro <name>, expected '('"
A macro defined as taking arguments was used without specifying
those arguments.
"Recursive use of macro <macroname>"
You called a macro recursively, this would lead to an infinite loop
"Macro crosses #include boundry"
A wierd error you should never get
"Replace Soft Error ..."
"Soft error ..."
Please report immediately! Software error within dcpp.
"Not enough arguments to macro"
You referenced a macro taking more arguments then you supplied!
"Maximum # of include/macro levels exceeded (32)"
DCPP can handle up to 32 levels of includes and macro nestings
"Size Error <file> (<offset>)"
"Read Error <file>"
These are errors associated with file access. "Size Error" in
particular is more indicative of a possible bug in DCPP
"stringtize '#' valid only before macro argument"
You may only stringtize a macro argument as in:
#define stringof(fubar) #fubar
Attempting to stringtize other tokens is illegal
"#if's left pending over from include after EOF: ..."
One or more #if's was left unclosed (i.e. no matching #endif)
at the end of a file. While you can nest #include's in #if's
you cannot start an #if in an #include and #endif it outside
that #include.
"Unexpected EOF (unterminated comment)"
A comment was left unterminated when the file EOF occured.
"cpp: unterminated string"
"cpp: unterminated '"
"unterminated character constant"
Unterminated string and/or character constants were detected
"syntax error"
"too many ')'"
"expression too complex"
These occur during DCPP expression parsing for #if's and are
indicative an problems in your expression
"directive: unexpected EOF"
An unexpected end-of-file occured while processing a # directive.
"Maximum # of if levels (256)"
You may only have up to 256 levels of #if nesting
"double #else ?"
Occurs when you have an #else without an #if, or something
like: #if fubar ... #else ... #else ... #endif, which is illegal.
"#endif without associated #if"
Occurs when you have an #endif without a matching #if.
"Expected " or <"
"Expected " or >"
#include's use "filename" or <filename> delimiting. Note that
DCPP does not handle macro expansion in #include statements yet.
***********************************************************************
* *
* *
* DC1 ERROR MESSAGES *
* *
* *
***********************************************************************
9: "Unexpected EOF"
The source or header file ended abruptly, for example ending in
the middle of a quoted string. More stuff was expected.
10: "Char Const Too Large!"
Only 4 characters are allowed within a character constant, more
than four, such as 'abcde' (the single quotes are part of the
example) will generate this error.
11: "NewLine in string constant"
A newline occurs within a string constant, such as the next
two lines:
"abcd
efgh"
This is not legal under ANSI C. Instead, you can create a single
large string using "string1" "string2" ... two sets of quotes
strings with no delimiter
12: "Illegal character '%c' $%02x"
Certain characters, such as '#' not part of a preprocessor
directive, are illegal. Example: int x = 43#;
13: "Unexpected Token '%s' expected '%s'"
The expected token wasn't the one we got! The error message
tells you what the character was and what was expected.
14: "__geta4 keyword does NOT work with residentable executables!"
__geta4 requires the data base to be at a known absolute
relocatable location. You cannot use __geta4 in conjuction
with -r because residentable code allocates its data segment
at run time.
15: "More than 32K of auto variables!"
DICE accesses all stack variables using word-register-relative,
thus no more than 32KBytes worth of stack variables may be
declared.
16: "struct/union return not supported yet"
This version of DICE does not yet support structural return
values from procedures.
17: "constant does not fit storage: %d"
DICE will, in some cases, catch the use of constants that are
out of range in a particular situation... for example, specifying
the constant '128' in relation to a signed character (-128 to 127).
DICE checks constant-fit only in hazzardous situations.
18: "size mismatch: %d, %d"
This is a code generation error which can occur when you
compare or run operations on incompatible types.
19: "repeated case: %d (0x%08lx)"
The specified case, given in both decimal and hex, occurs more
than once within a switch statement.
20: "block operation error in source"
21: "block operation error in dest"
Generally means that either the source or the destination of
a block-op, such as a structure assignment, are incompatible.
For example:
foo = bar;
where foo has a different structure type than bar. Generally
this error is preceeded by an "illegal assignment" error.
22: "dest not lvalue"
Generally occurs if the object of an assignment is not assignable.
However, note that DICE is notably weak in this area... it will
cheerfully allow you to do things like (a + b) = c + d;, obviously
illegal.
23: "syntax error in expression"
A General syntax error in an expression occured. Usually occurs
due to an illegally constructed expression, such as: a ] b;
can also occur due to too few parenthesis.
24: "expected expression"
An expression was expected when, instead, either nothing or a
statement was found. This can also occur due to a syntax error
in the expression.
"expected '}'"
A close brace was expected, for example, a global declaration
such as: int a[] = { 1, 2, 3;
"expected %d close parens"
Expected one or more close parenthesis in an expression.
"expected close bracket"
Expected a close bracket ']', generally caused by an incomplete
array index such as a[i = 4;
"expected identifer after . or ->"
A structure indirection via '.' or '->' requires a structure
member to be specified. i.e. a field name.
"expected ',' or ')' in function call"
Expected a delimiter in a function call... either comma if another
argument is to be given, or a close parenthesis to end the function
call.
"undefined symbol: %s"
The given symbol is not defined. For example, referencing a
variable that was not defined or extern'd.
"expected integer constant"
An integer constant was expected, generally occurs when you
declare an array. For example, the following is illegal:
int i[j];
"not an lvalue"
Occurs when an lvalue was expected, usually in an assignment. An
lvalue is an expression which exists in real storage, for example:
*ptr = 4; ... the expression '*ptr' points to real storage where
as the expression (a + b) in (a + b) = 4; does NOT. Note that DICE
is not very good at catching lvalues errors yet.
"goto label not found"
One or more 'goto label;' statements in a procedure specifies
a non-existant label.
"constant div/mod by 0"
You attempted to use the '/' or '%' operator with the constant
value 0 on the right hand side. Division/Modulus by 0 is illegal.
"ptr-ptr mismatch"
Generally occurs in a pointer comparison or assignment. The
two pointers do not point to the same type. Example,
char *a; long *b; if (a < b);
"unexpected void type"
Occurs due to an illegally constructed expression where the
result storage is void.
"result not used"
This warning occurs in some cases where an expression has been
calculated but the result ends up not being used.
"& of array redundant"
Example: int a[4]; int *b = &a; ... the '&' is redundant
because accessing an array variable without any index yields
a pointer to the array anyway.
"& of bitfield illegal"
It is not legal to take the address of a bitfield element in
a structure since no pointer representation is possible.
"indirection through non-ptr"
int a; *a = 4; ... i.e. where 'a' wasn't a pointer. Will also
occur if you attempt to index a variable which is not an array
or pointer, i.e. a[4] = 4; where 'a' is an integer instead of an
array/pointer.
"must #include <alloca.h> for alloca"
DICE requires a special alloca. To obtain it any modules that use
alloca() must #include <alloca.h> which redefines it properly.
"lhs not a procedure"
You attempted to make a procedure call, such as foo(23); where
foo is not a procedure. Example: int foo; foo(23); This
can occur if you accidently declare a variable whos name is
the same as a procedure you attempt to call.
"unprototyped call"
When the -proto option to DCC is used, any procedure call which
is not prototyped will generate this error.
"too few parameters in call"
"too many parameters in call"
For prototyped procedures, the number of arguments is generally
known. DICE will print these warnings if you make a procedure
call with too few or too many arguments.
"not structure or union type"
An attempt was made to indirect through a structure or union
where the lhs (left hand side) was not a structure or union type.
"maximum auto storage for temporaries exceeded"
DICE tracks stack temporaries, mainly for floating point. If
DICE's maximum number of temporaries is exceeded due to an
overly complex expression, this error will be given.
"register not allocated: %d"
This is generally an indication of a software error within DC1
if not preceeded by other error messages.
"expected integer type"
An integer type was expected but instead a non-integer type was
found... for example, trying to use a float to index an array.
"illegal ptr arithmatic"
This error generally occurs when you do something illegal with
a pointer. For example, while 'ptr - i' is valid, 'i - ptr'
is not. While you can subtract two pointers 'p1 - p2', you
cannot add to pointers 'p1 + p2'.
"illegal ptr conversion"
"illegal structure conversion"
"illegal cast"
"illegal int conversion"
It is illegal to convert an integer to a structure or vise-versa,
generally the error occurs through an explicit cast. An illegal
cast is a catch all for casts that DICE does not understand ...
things like converting integers into arrays and other nonsense.
"ptr-int conversion"
"int-ptr conversion"
generally occurs when DICE was forced to convert an integer to
a pointer or vise-versa, such as making a procedure call and
passing an integer when the procedure expected a pointer.
"int/ptr mismatch"
Generally occurs when you compare two unlike types (an integer
and a pointer).
"illegal or incompatible structure operation"
When you assign structures to each other they must be of the same
type & size. May also occur if you accidently assign a structure
to a non-structure or vise-versa.
"illegal assignment"
The assignment is illegal. Usually occurs if you attempt to
assign a field in a structure in the structure definition,
like:
struct foo {
int x = 4; /* huh ?? */
};
"illegal ptr-int or int-ptr conversion, int-size != ptr-size"
This is catch-all for programs that convert between pointers and
integers and vise-versa. You can only convert an int or long to a
pointer and back in DICE. Converting to or from a short is
illegal.
"illegal bit-field operation"
The bitfield operation is not legal. Generally occurs when you
attempt to declare a bitfield not part of a structure or union.
"illegal compare"
Generally occurs when you attempt to compare two structures.
You can only use == and != when comparing structures.
"undefined structure tag"
Generally occurs when you attempt to reference a field in a
structure which has yet to be defined.
"undefined struct/union field: %s"
The specified field does not exist in the structure definition.
"ran out of memory"
DICE ran out of memory. The README file outlines possible steps
to take ranging from making fewer things resident to specifying
a temporary directory on your HD instead of in T: (usually
assigned to RAM:)
"fp constant string too long!"
Hey buddy! Your floating point constant is too long (> 128 digits).
DICE can only handle so much.
"fp constant too large to convert to int"
The fp constant is less than -0x80000000 or larger than 0x7FFFFFFF
and thus cannot be converted to an integer.
"expected semicolon"
A semicolon was expected. For example:
int a <--- oops
int b;
Generally occurs when something unexpected happens, a semicolon is
not always the correct solution. For example, can occur if you
have too many close braces.
"illegal type/storage qualifier for variable"
The type or storage qualifier is illegal for this variable
declaration.
"illegal typedef"
The typedef is illegal.
"multiply defined procedure"
You have defined a procedure (definition means procedure
declaration with { ... code ... }) more than once in the same
source file.
"type too complex"
Occurs if a type is too complex for DICE to handle. For example,
DICE cannot deal with an array with 32 dimensions.
"syntax error in declaration"
"enum identifier overides variable/type"
Occurs if you create an enum identifier that overides an existing
typedef or variable.
"id missing in procedure declaration"
"procedure id decl not in id list"
This occurs if you declare a procedure with arguments old style
and mistakenly declare a variable that wasn't specified in the
identifier list.
int
fubar(a,b,c)
int a, b, c, d;
{
}
Note that the variable 'd' did not exist in the id list.
"statement's condition must be an expression"
RETURN, IF, DO and WHILE require an expression or nothing. The
middle argument for FOR() requires an expression. Whatever you
gave the compiler, it wasn't an expression.
"duplicate default: in switch"
You have more than one default: statement in a switch.
"statements before first case in switch"
Again, strict ANSI says it is ok to have statements before a
switch though it says nothing as to how they are supposed to
get executed.
switch(fubar) {
x = 4;
case 1:
...
}
But DICE will generate an error.
"expected '{' or '}' for procedure def"
Just a more specific error message to the general syntax error.
There is something wrong with your procedure definition, DICE
expected an open brace and then the procedure but didn't see
an open brace.
"case/default outside switch"
with DICE, the case and default statements must be on the same
semantic level as the switch() { ... } even though ANSI says
they can be in lower levels. At least for now. The other
common cause is if you really do have a case or default statement
outside of the switch statement.
"else without if"
You have an ELSE statement not associated with any IF statement.
The most common mistake is when you accidently put two statements
in between an IF and an ELSE without using braces, like this:
if (i == 0)
i = 1; j = 2; /* wrong, need braces if more than one stmt */
else
i = 3;
Which more commonly occurs if you use #define macros heavily.
***********************************************************************
* *
* *
* DLINK ERROR MESSAGES *
* *
* *
***********************************************************************
"Cannot Frag if Resident"
The -frag option may not be used in conjuction with the -r resident
option, they are mutually exclusive since -r implies all
non-constant data is A4-relative accessible.
"Couldn't open <filename>"
DLink was unable to open the requested file name
"Bad hunk in <file> <hunkid> at offset <offset_in_file>"
"Not an object module: <filename> at offset <offset_in_file>"
"Unknown hunk type <type> in <filename>"
DLink is unable to interpret the hunk type in a library or object
module
"Couldn't create <filename>"
DLink is unable to create the requested executable file
"Read failed for <filename>"
A read() operation on the specified file has failed
"Warning, hunk has no code, data, or bss <hunkname> in <filename>"
Indicates that a hunk group in an object module or library does
not contain any code, data, or bss hunks
"COMMON symbol not supported, module <modulename>"
DLink does not support COMMON symbols yet
"Symbol type <type> unknown in <filename>"
A symbol entry in the specified object module or library has a
type unknown to DLink
"Illegal object format in <filename>"
An object in the file exceeds the size of the file (i.e. corrupt)
"Object format error h>mh"
"Object format error h!=mh"
A Hunk reference in an object module goes beyond the number of
hunks in that object module, i.e. access to non-existant hunk.
The second message occurs when the number of hunks counted in pass 2
does not match the number of hunks counted in pass 1, usually due
to a corrupt object module
"Soft error, more than one final data"
"Didn't expect a second BSS after coagulating"
A software error has occured, when -frag is not specified all
normal data and bss hunks are coagulated together. This error
occurs if, after coagulation, there are normal hunks remaining
that somehow did not get coagulated.
"Data hunk is empty"
This can occur if a link winds up with no data hunks whatsoever.
You need at least one for the linker to be able to generate
its special linker symbols (though it can be empty)
"PC-rel offset >+/-32K within a hunk!"
This occurs when you have large object modules which attempt
to run a pc-relative access whos offset is larger then a
signed short. Generally the solution is to compile that
module -mC (large-code) or specify the object(s) in question
as being __far
"inter-module PC-rel jump >32K!"
Generally occurs with branch statements that cannot reach their
desetination with a signed-short
"range error <hunkname> <offset>"
Occurs when an object module contains a relative relocation
that goes beyond the boundries of the hunk
"out of memory"
Occurs when DLink runs out of memory
"size error <generated>/<calculated>"
"reloc array size mismatch <actual>/<calculated>"
"reloc_copy error, array too small <actual>/<calculated>"
These are software errors -- a sanity check DLink makes with
itself has failed
"Error, cannot have data-data relocations if resident"
DICE's resident support is handled by the main compiler, DC1, which
will generate static data that never contains 32 bit data-data
relocations (instead generating run-time code to handle such
relocations). If any 32 bit data-data relocations exist, DLink
cannot make a program residentable.
"32 bit reloc hunk ... to hunk ..."
When you use the -pi option for position independant code linking,
DLink will complain if there are any absolute code relocations in
the link.
"No relocation info allowed for BSS data!"
BSS is exactly that... BSS, zero'd. You cannot have relocations
that modify BSS space (you can, of course, have data relocations
that *reference* BSS space).
"Relocation beyond end of hunk"
The object module is corrupt, a relocation was requested that
goes beyond the initialized data or code in a hunk
"PC-Relative access to type <type> label"
You may only make pc-relative accesses to normal type 1 symbols
"Absolute references to BSS space variables are Illegal"
"Absolute References to DATA space variables are Illegal"
This error message occurs for -r or -pi linking (resident or
position independant code). Since BSS and DATA addresses are
not known until run-time, no absolute references to BSS/DATA
are allowed.
"Error, PC rel reloc <file>:<hunk> to <file>:<hunk>"
You cannot make PC relative references between hunks that do
not wind up coagulated since they are not contiguous in memory.
"Illegal A4-ref to far object: <where_object_defined> from <where A4-ref occurs>
It is illegal to make small-data accesses to objects declared as
__far or compiled with -mD ... this can occur, for example, if you
compile a module -mD and declare a library base variable, say,
IntuitionBase, which is then referenced by the OpenScreen() tag
as small-data due to the use of the small-data amiga.lib
The solution is to either not compile the module __far or to leave
the -mD option in and declare IntuitionBase as __near, as in:
__near long IntuitionBase;