A conditional in the C preprocessor begins with a conditional directive: #if, #ifdef or #ifndef.
4.2.1. Ifdef

The simplest sort of conditional is

#ifdef MACRO

controlled text

#endif /* MACRO */


This block is called a conditional group. controlled text will be included in the output of the preprocessor if and only if MACRO is defined. We say that the conditional succeeds if MACRO is defined, fails if it is not.

The controlled text inside of a conditional can include preprocessing directives. They are executed only if the conditional succeeds. You can nest conditional groups inside other conditional groups, but they must be completely nested. In other words, #endif always matches the nearest #ifdef (or #ifndef, or #if). Also, you cannot start a conditional group in one file and end it in another.

Even if a conditional fails, the controlled text inside it is still run through initial transformations and tokenization. Therefore, it must all be lexically valid C. Normally the only way this matters is that all comments and string literals inside a failing conditional group must still be properly ended.

The comment following the #endif is not required, but it is a good practice if there is a lot of controlled text, because it helps people match the #endif to the corresponding #ifdef. Older programs sometimes put MACRO directly after the #endif without enclosing it in a comment. This is invalid code according to the C standard. CPP accepts it with a warning. It never affects which #ifndef the #endif matches.

Sometimes you wish to use some code if a macro is not defined. You can do this by writing #ifndef instead of #ifdef. One common use of #ifndef is to include code only the first time a header file is included. Section 2.4 Once-Only Headers.

Macro definitions can vary between compilations for several reasons. Here are some samples.

*

Some macros are predefined on each kind of machine (Section 3.7.3 System-specific Predefined Macros). This allows you to provide code specially tuned for a particular machine.
*

System header files define more macros, associated with the features they implement. You can test these macros with conditionals to avoid using a system feature on a machine where it is not implemented.
*

Macros can be defined or undefined with the -D and -U command line options when you compile the program. You can arrange to compile the same source file into two different programs by choosing a macro name to specify which program you want, writing conditionals to test whether or how this macro is defined, and then controlling the state of the macro with command line options, perhaps set in the Makefile. Chapter 12 Invocation.
*

Your program might have a special header file (often called config.h) that is adjusted when the program is compiled. It can define or not define macros depending on the features of the system and the desired capabilities of the program. The adjustment can be automated by a tool such as autoconf, or done by hand.

4.2.2. If

The #if directive allows you to test the value of an arithmetic expression, rather than the mere existence of one macro. Its syntax is

#if expression

controlled text

#endif /* expression */


expression is a C expression of integer type, subject to stringent restrictions. It may contain

*

Integer constants.
*

Character constants, which are interpreted as they would be in normal code.
*

Arithmetic operators for addition, subtraction, multiplication, division, bitwise operations, shifts, comparisons, and logical operations (&& and ||). The latter two obey the usual short-circuiting rules of standard C.
*

Macros. All macros in the expression are expanded before actual computation of the expression

Answered by M P , an ibibo Master, at 5:39 PM on October 06, 2008

well, One of our main design goals for C is to keep the code very readable. Having the ability to write macros gives the programmer the ability to create their own language - one that doesn't necessarily bear any relation to what the code underneath. To understand what the code does, the user must not only understand how the language works, but he must also understand all of the define macros that are in effect at that point in time. That makes code much harder to read.

In C, you can use methods instead of macros, and in most cases, the JIT will inline them, giving you the same performance aspect.
source site: http://blogs.msdn.com/csharpfaq/arc hive/2004/03/09/86979.aspx

Answered by Romi , an ibibo Master, at 6:00 PM on September 26, 2008

Basic Structure of a Macro

The basic structure is as follows:

define int my_macro(parameter) – definition (return type, name, parameters)
int parameter; – setting the types of the parameters
{
// Body of macro – body enclosed within {}
}
. – a '.' denotes the end of the macro definition

Comments can either be designated using //, or /* .... */. A single comment can not span multiple lines.

// Acceptable comment


/* Also ok */

/*
Not ok
*/

Accessing Global & Local Symbols

Macros can access global symbols (symbols in RVD's symbol table) and local symbols defined within the macro itself. Local symbols only exist for the duration of the macro's execution. If you define a local symbol with the same name as a global symbol, the local will be used in preference.

Macros are themselves stored as symbols within the symbol table. This allows a macro to call any other loaded macro as if it were a subroutine. For example:

define int macro1()
{
int number; – Declare a local variable (local symbol)
number = macro2() – Call another macro, placing its return value into 'number'
return number;
}
.

Answered by Sharad Singh , an ibibo Master, at 6:05 PM on September 24, 2008

A preprocessor 'macro' can define a constant according to the result of a test made with an #if directive to evaluate an expression. Depending upon the result of this test the macro could then #define a constant. The macro must end with an #endif directive.

The existence of a constant definition can be tested for with an #ifdef directive. This is used in the following example to test for the existence of a system constants that are defined by the C compiler. A constant called SYS is then defined as a text string appropriate to the host the operating system.

#include <stdio.h>
#ifdef _WIN32
#define SYS "Windows"
#endif
#ifdef linux
#define SYS "Linux"
#endif

int main ()
{
printf("Operating System: %s\n", SYS);
return 0;
}

Answered by Nishu's , an ibibo Master, at 2:31 PM on September 08, 2008

well, If it's for registers, maybe you could use extended asm syntax like this:

#define REG "a"
int x;

__asm__ __volatile__ (" \n\
movl %0, 0x01 \n\
"
:"="REG(x)
:
);

Answered by Satya ~ , an ibibo Master, at 12:29 PM on September 08, 2008

Early macro systems for C-like languages were based on character substitution. A typical example is:
#define FOO "abc
Such systems are unsafe in the sense that the macro can produce ill-formed syntax and non-tokens. The C preprocessor was a small step forward; it is essentially a filter on the token stream produced by the lexer. The most prevalent problem with CPP is illustrated by the following example:
#define SCALE(a) (a * 0.75)
The result of SCALE(3 + 2) most likely does not capture the intent of the programmer. Even worse, a programmer may not notice the presence of the error until long after the (3 + 2 * 0.75) computation takes place.

Weise and Crew argue that macros should work on the level of ASTs rather than tokens, and they provide three criteria that a macro system must satisfy.

1. noninterference: SCALE(3+2) should work as intended.
2. syntactic abstraction: We want to define DSLs.
3. syntactic safety: Macros should not be able to produce non-well-formed syntax.

They introduce quasiquote, unquote, and a syntactic type system.

Say you want a macro to create enumeration types; you might use it like this:

new_enum color {red, green, blue}

One can define this in Weise et. al's system like this:

syntax decl[] new_enum {| $$id::name {$$+\, id::ids}; |}
{ ... body ... }

This demonstrates that they are capable of destructuring input syntax. The system does not solve hygiene, but it does provide a gensym facility. The paper claims that the syntax type system guarantees that macros do not produce ill-formed syntax. The authors provide neither an algorithm nor a theorem. The most important contribution of this paper is that the authors demonstrate that macro systems are not tied to s-expressions.

For more visit :

http://www.ccs.neu.edu/ho me/matthias/369-s04/Transcript s/macro-talk.html

Answered by Ashish Yadav , an ibibo Wizard, at 10:45 AM on September 08, 2008

well, A macro (from the Greek 'μάκρο' for long or far) in computer science is a rule or pattern that specifies how a certain input sequence (often a sequence of characters) should be mapped to an output sequence (also often a sequence of characters) according to a defined procedure. The mapping process which instantiates a macro into a specific output sequence is known as macro expansion.
If it's for registers, maybe you could use extended asm syntax like this:

#define REG "a"
int x;

__asm__ __volatile__ (" \n\
movl %0, 0x01 \n\
"
:"="REG(x)
:
);

use a C macro inside the asm instruction.But inside
> the asm instruction macro is not replaced by macro definition. Is there
> anyway I can do that.
>
> Here is an Example what I want to do.
>
> #define Register R0
>
> asm("mov Register, #1");
>

> there any option which could do that.
all the best!

Answered by Nidhi Singh , an ibibo Master, at 10:22 AM on September 08, 2008

A macro in computer science is a rule or pattern that specifies how a certain input sequence (often a sequence of characters) should be mapped to an output sequence (also often a sequence of characters) according to a defined procedure. The mapping process which instantiates a macro into a specific output sequence is known as macro expansion.

A macro can be declared to accept a variable number of arguments much as a function can. The syntax for defining the macro is similar to that of a function. Here is an example:

#define eprintf(...) fprintf (stderr, __VA_ARGS__)

This kind of macro is called variadic. When the macro is invoked, all the tokens in its argument list after the last named argument (this macro has none), including any commas, become the variable argument. This sequence of tokens replaces the identifier __VA_ARGS__ in the macro body wherever it appears. Thus, we have this expansion:

eprintf ("%s:%d: ", input_file, lineno)
==> fprintf (stderr, "%s:%d: ", input_file, lineno)

The variable argument is completely macro-expanded before it is inserted into the macro expansion, just like an ordinary argument. You may use the `#' and `##' operators to stringify the variable argument or to paste its leading or trailing token with another token. (But see below for an important special case for `##'.)

If your macro is complicated, you may want a more descriptive name for the variable argument than __VA_ARGS__. CPP permits this, as an extension. You may write an argument name immediately before the `...'; that name is used for the variable argument. The eprintf macro above could be written

#define eprintf(args...) fprintf (stderr, args)

using this extension. You cannot use __VA_ARGS__ and this extension in the same macro.

You can have named arguments as well as variable arguments in a variadic macro. We could define eprintf like this, instead:

#define eprintf(format, ...) fprintf (stderr, format, __VA_ARGS__)

This formulation looks more descriptive, but unfortunately it is less flexible: you must now supply at least one argument after the format string. In standard C, you cannot omit the comma separating the named argument from the variable arguments. Furthermore, if you leave the variable argument empty, you will get a syntax error, because there will be an extra comma after the format string.

eprintf("success!\n", );
==> fprintf(stderr, "success!\n", );

For more information-
http://developer .apple.com/documentation/Devel operTools/gcc-4.0.1/cpp/Variad ic-Macros.html

Answered by Nagendra , an ibibo Master, at 8:14 AM on September 08, 2008

Well Mamata , A unique feature of c language is the preprocessor. A program can use the tools provided by preprocessor to make his program easy to read, modify, portable and more efficient.

Preprocessor is a program that processes the code before it passes through the compiler. It operates under the control of preprocessor command lines and directives. Preprocessor directives are placed in the source program before the main line before the source code passes through the compiler it is examined by the preprocessor for any preprocessor directives. If there is any appropriate actions are taken then the source program is handed over to the compiler.

Preprocessor directives follow the special syntax rules and begin with the symbol #bin column1 and do not require any semicolon at the end. A set of commonly used preprocessor directives


The preprocessor directives can be divided into three categories
1. Macro substitution division
2. File inclusion division
3. Compiler control division
Macros:

Macro substitution is a process where an identifier in a program is replaced by a pre defined string composed of one or more tokens we can use the #define statement for the task.

It has the following form
#define identifier string

The preprocessor replaces every occurrence of the identifier int the source code by a string. The definition should start with the keyword #define and should follow on identifier and a string with at least one blank space between them. The string may be any text and identifier must be a valid c name.

There are different forms of macro substitution. The most common form is
1. Simple macro substitution
2. Argument macro substitution
3. Nested macro substitution
Simple macro substitution:

Simple string replacement is commonly used to define constants example:

#define pi 3.1415926

Writing macro definition in capitals is a convention not a rule a macro definition can include more than a simple constant value it can include expressions as well. Following are valid examples:

#define AREA 12.36
Macros as arguments:

The preprocessor permits us to define more complex and more useful form of replacements it takes the following form.

# define identifier(f1,f2,f3…..fn) string.

Notice that there is no space between identifier and left parentheses and the identifier f1,f2,f3 …. Fn is analogous to formal arguments in a function definition.

There is a basic difference between simple replacement discussed above and replacement of macro arguments is known as a macro call

A simple example of a macro with arguments is

# define CUBE (x) (x*x*x)

If the following statements appears later in the program,

volume=CUBE(side);

T he preprocessor would expand the statement to

volume =(side*side*side)
Nesting of macros:

We can also use one macro in the definition of another macro. That is macro definitions may be nested. Consider the following macro definitions

# define SQUARE(x)((x)*(x))
Undefining a macro:

A defined macro can be undefined using the statement

# undef identifier.
This is useful when we want to restrict the definition only to a particular part of the program.

For more details , Please visit the source site :

http://www.exforsys.com/tutori als/c-language/the-preprocessor-in- c.html

Answered by Alok Gupta , an ibibo Guru, at 6:35 PM on September 07, 2008

# define macro-name (formal parameter) expression

for example you want to find out the area of the circle
then you can use like it
# define area (r) ((3.14)*(r)*(r))

Answered by Umesh Kumar at 6:05 PM on September 07, 2008