Obstack Functions - The GNU C Library

Next: Growing Objects, Previous: Freeing Obstack Objects, Up: Obstacks

##### 3.2.4.5 Obstack Functions and Macros

The interfaces for using obstacks may be defined either as functions or as macros, depending on the compiler. The obstack facility works with all C compilers, including both ISO C and traditional C, but there are precautions you must take if you plan to use compilers other than GNU C.

If you are using an old-fashioned non-ISO C compiler, all the obstack “functions” are actually defined only as macros. You can call these macros like functions, but you cannot use them in any other way (for example, you cannot take their address).

Calling the macros requires a special precaution: namely, the first operand (the obstack pointer) may not contain any side effects, because it may be computed more than once. For example, if you write this:

         obstack_alloc (get_obstack (), 4);

you will find that `get_obstack` may be called several times. If you use `*obstack_list_ptr++` as the obstack pointer argument, you will get very strange results since the incrementation may occur several times.

In ISO C, each function has both a macro definition and a function definition. The function definition is used if you take the address of the function without calling it. An ordinary call uses the macro definition by default, but you can request the function definition instead by writing the function name in parentheses, as shown here:

         char *x;
         void *(*funcp) ();
         /* Use the macro.  */
         x = (char *) obstack_alloc (obptr, size);
         /* Call the function.  */
         x = (char *) (obstack_alloc) (obptr, size);
         /* Take the address of the function.  */
         funcp = obstack_alloc;

This is the same situation that exists in ISO C for the standard library functions. See Macro Definitions.

Warning: When you do use the macros, you must observe the precaution of avoiding side effects in the first operand, even in ISO C.

If you use the GNU C compiler, this precaution is not necessary, because various language extensions in GNU C permit defining the macros so as to compute each argument only once.