Marco translation help

[jwroblewski44]

Hello everyone. I am working on a non-graded project and am in need of some help. I have this bit of code that I wish to turn into a macro, but I am REALLY lacking in knowledge in that department. Since I'm not really focusing on macros right now, I was wondering if someone could translate my code snippet into a macro for me? It would help me understand the syntax as well. Thanks in advance.

if( *pstack && *pstack->type == OPERAND && 
   *pstack->linked_token && ( *pstack->linked_token )->type == OPERAND )

[laserlight]

You want to turn the if statement into a macro, or the conditional expression? Assuming the latter, start with: what are the variables?

[jwroblewski44]

I am really sorry. I forgot to include the definitions and what-not. And yes, to be more specific, I would like the conditional statement to be translated into a macro that would have the same result as the if statement.

/* enable (1) or disable (0) parentheses checking in parsing strings */
/* leave disabled for part (a); enable for part (b) */
#define PARSE_PARENS 0


/* type of token */
enum token_type {
    OPERAND, /* number */
    OPERATOR, /* operator: +, -, *, / */
#if PARSE_PARENS
    LPARENS, /* left parentheses ( */
    RPARENS /* right parentheses ) */
#endif
};


/* operator identifiers (opcodes) */
enum op {
    ADD, /* a+b */
    SUBTRACT, /* a-b (binary) */
    MULTIPLY, /* a*b */
    DIVIDE, /* a/b */
    NEGATE /* -a (unary) */
};


/* direction of evaluation (associativity) */
enum assoc {
    LEFT, /* left-to-right (+, binary -, *, /) */
    RIGHT /* right-to-left (unary -) */
};


/* number of operands for each operator type */
const unsigned int op_operands[] = {2, 2, 2, 2, 1};


/* order-of-operations (precedence) (0 = evaluated last) */
const unsigned int op_precedences[] = {0, 0, 1, 1, 2};


/* evaluation direction (associativity) for each precedence level */
const enum assoc op_associativity[] = {LEFT, LEFT, RIGHT};


/* contains value of token */
union token_value {
    double operand; /* numeric value for operand */
    enum op op_code; /* opcode for operators */
};


/* data structure for token */
typedef struct s_expr_token {
    union token_value value; /* numeric value or opcode */
    enum token_type type; /* type of token */


    struct s_expr_token * linked_token; /* linked token in stack/queue */
} * p_expr_token; /* p_expr_token is shorthand for "struct s_expr_token *" */

Those are global to the whole program.

This is declared within the function I am writing, which is where I would declare the macro. I only need this macro inside this function.

p_expr_token * pstack;*pstack = NULL;   /* holds pointer to top of token stack */
p_expr_token ptoken;                    /* current token */

EDIT: I am just lazy as all get-out, and don't want to retype that long if statement when I could shorten it to a small macro.

[laserlight]

It seems to me that you want something like:

#define CHECK_OPERAND_TOKENS(pstack) (*(pstack) && *(pstack)->type == OPERAND && \
                                      *(pstack)->linked_token && (*(pstack)->linked_token)->type == OPERAND)

To be used as:

if( CHECK_OPERAND_TOKENS(pstack) )

[jwroblewski44]

That is exactly what I am looking for! Thank you very much Laserlight.

It seems the syntax is to just put parenthesis around the parameter inside the expression? I assume the backslash is necessary to indicate the expression continues on the next line?

[laserlight]

Yeah, I just copied and pasted your code, added the parentheses with the backslash to get a second line for formatting purposes. The parentheses are unnecessary, but better safe than sorry since you might later use a more complicated expression. Same reason for the surrounding parentheses.

[Barney McGrew]

The unary * operator is evaluated after the -> operator, so your code applies -> to an incorrect type. My understanding is that you want to ensure that the first member is an operand and the next member is also an operand. In that case you'd be better off writing a function whose name takes a predicate form, for instance:

int double_operand(const struct s_expr_token *token)
{
    return token && token->type == OPERAND && token->next
        && token->next->type == OPERAND;
}

This makes it easy to read when used with an if statement or while statement:

if (double_operand(*pstack)) /* if *pstack is a double operand */

if (!double_operand(*pstack)) /* if *pstack is not a double operand */

[jwroblewski44]

The unary * operator is evaluated after the -> operator, so your code applies -> to an incorrect type.

Very good point. I believe I could remedy the macro by adding some parenthesis?

#define CHECK_OPERAND_TOKENS(pstack) (*(pstack) && (*(pstack))->type == OPERAND && \
                                      (*(pstack))->linked_token && ((*(pstack))->linked_token)->type == OPERAND)

Force the dereference before taking the data memeber?

[laserlight]

You could, but frankly, just going for a function would be simpler if you don't actually need to ensure that the code is inlined. Furthermore, since this is a helper function, you might just define it as static in the source file without declaring it in the header, and maybe the compiler will inline it anyway.

[jwroblewski44]

Thanks for all the advice. I will have to think about how I want to do this. I am pretty sure I want to accomplish this with a macro so I will probably just pass the actual token_pointer that pstack is pointing to in order to avoid the deferencing problems.

[Barney McGrew]

Why do you want to use a function-like macro? No type checking is performed on the arguments that are passed to them, rather, they're simply inserted into the replacement expression. At some point you'll probably need to take into consideration that the parameter used by your macro is evaluated four times, so if you happen to pass an expression with side effects they'll be performed each time the expression is evaluated. They're better used for defining syntax rather than functions.

[jwroblewski44]

Well the macro is used on the same variable every time it's used, so I have no worries about the type being passed. I do realize that it isn't very portable, as-in useful in other programs.

I have the same if statement that would have been in my file in multiple places, so this is just a shorthand replacement. Honestly, I really just wanted to learn/use a macro.

I am curious as to what you mean that macro's are better used for "defining syntax"?

[Barney McGrew]

I am curious as to what you mean that macro's are better used for "defining syntax"?

For instance, if you wanted to define your own syntax for traversing a linked list:

#define for_each_tail(cursor, lst) for(cursor = lst; cursor; cursor = (cursor)->next)

This could be used like so:

for_each_tail(np, lst) {
        print(np->data);
}

EDIT: Some fancier stuff:

#define for_each(cursor, lst) for (<list type> c_ = lst; c_ && (cursor = c_->data, 1); c_ = c_->next)

C's macro system isn't really sophisticated enough for doing things like this though.