11.5 Inline functions

----------------------

'Inline' functions can be dynamic functions which are used as macros,

but unlike macros, these functions, when you are optimizing for speed, are

automatically inserted into the code, and when you are optimizing for size,

are called as dynamic functions.

Sometimes, however, it is necessary when optimizing for code size for

the functions to be inserted into the code and not called. This can be done

using the directive '#inline TRUE'. This same directive (as '#inline

FALSE') can cause functions to be called instead of inserted when

optimizing for speed.

Note that the status of '#inline' automatically changes when the

optimization condition changes. When you are optimizing for speed, #inline

is TRUE, but when you change to optimization for code size, it is set to

FALSE. This directive should therefore be applied only after changing the

optimization condition.

Directives which change the optimization conditions #codesize and

#speed, along with #inline are declared inside a function only on the

remaining part of the function, i. e., they are local directives. In order

for the changes to be global, these directives must be declared outside of

the body of the function.

To define an inline function, the first string with the function name

must contain instead of ':', which indicates a dynamic function, the

keyword 'inline'. For example:

inline int fastcall abs(AX)

{

IF ( int AX < 0 ) -AX ;

}

11.5.1 Another use of 'inline'

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The keyword 'inline' has another use in functions. If this word is

found before the start of a function block, no stack frame is created for

this function and no 'ret' is generated to close the function. For

example:

void PROC ()

inline

{

...

}

Such functions cannot contain local variables. If this is a register

function (of type 'fastcall') there is no problem in transferring its

parameters. If, however, it is a stack function, parameters can be

transferred to this function but these functions cannot be called via

their names. This is because a stack frame is not formed in these

functions.

For example:

void proc (int par1, par2)

inline

{

AX=par1; /* the compiler addresses with parameter 'par1' through

register BP. But since frame of stack was not created,

when performing this code a program will work not

correctly. */

...

}

The compiler addresses with parameter 'par1' via register BP. But

since no stack frame was created, the program will not work properly when

executing this code.

On encountering such a function definition, the compiler will warn

that local and formal parameters cannot be used in such functions.