Passing Argument Values - Texas Instruments TI-89 Software Manual

Section 2: Compiler
When the file containing the above example is compiled, the following warning
will be issued:
This message is generated because the prototype declaration declares a
function that accepts a short parameter, while the function definition declares a
function that accepts an int parameter. The formal parameter in the function
definition is recognized as an int because the function definition is in the old-style
format; therefore, the integral promotion rules are applied to the short
parameter. To further understand the problem, examine the case in which a
short is pushed as two bytes in the presence of a prototype. A two-byte value
will be pushed onto the stack because a prototype declaration is in scope;
however, a four-byte argument will be expected inside the function that was
defined using the old style. A problem also results if a function that is defined with
a prototype to accept a short is called with an old-style declaration (or no
declaration) in scope.
The above problems can be avoided through exclusive use of prototype
declarations and definitions. The compiler command line flags -Xf1, -Xf2, and
-Xf3 can be used to verify that appropriate declarations are being utilized. The
-Xf1 flag causes a warning to be issued when a function is called outside the
scope of a function declaration. The -Xf2 flag causes a warning to be issued
when a function is declared without a prototype. The -Xf3 flag (the combination
of -Xf1 and -Xf2) causes a warning to be issued if a function is called without a
prototype declaration in scope.
2.11.2.

Passing Argument Values

Several factors determine how an argument value is pushed onto the stack when
a function call is made: the specified command line flags, the type of the
argument, and whether or not a function prototype is in scope. If a function
prototype is not in scope, the integral and floating-point promotion rules will be
applied to the argument types.
The -XI flag instructs the compiler to interpret objects of type int as 16 bits
rather than 32 bits (default). Specifying the -XI flag, as on the TI-89 / TI-92 Plus,
will cause all integer types (except for type long) to be passed as 16-bit objects
independent of whether a function prototype is in scope. The -Os# flags
determine how argument values of different types are passed only in the
presence of a function prototype. In the presence of a prototype, parameters of
type char and short are pushed as two-byte objects when the -Os2 flag is
specified, and are pushed as four-byte objects when the -Os4 flag is specified.
TI-89 / TI-92 Plus Sierra C Assembler Reference Manual
warning: incompatible parameter types, func() arg 1
Not for Distribution
77
Beta Version February 2, 2001