ReactOS  0.4.13-dev-235-g7373cb3
expr.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  expr_loc
 

Functions

expr_tmake_expr (enum expr_type type)
 
expr_tmake_exprl (enum expr_type type, int val)
 
expr_tmake_exprd (enum expr_type type, double val)
 
expr_tmake_exprs (enum expr_type type, char *val)
 
expr_tmake_exprt (enum expr_type type, var_t *var, expr_t *expr)
 
expr_tmake_expr1 (enum expr_type type, expr_t *expr)
 
expr_tmake_expr2 (enum expr_type type, expr_t *exp1, expr_t *exp2)
 
expr_tmake_expr3 (enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3)
 
const type_texpr_resolve_type (const struct expr_loc *expr_loc, const type_t *cont_type, const expr_t *expr)
 
int compare_expr (const expr_t *a, const expr_t *b)
 
void write_expr (FILE *h, const expr_t *e, int brackets, int toplevel, const char *toplevel_prefix, const type_t *cont_type, const char *local_var_prefix)
 

Function Documentation

◆ compare_expr()

int compare_expr ( const expr_t a,
const expr_t b 
)

Definition at line 867 of file expr.c.

868 {
869  int ret;
870 
871  if (a->type != b->type)
872  return a->type - b->type;
873 
874  switch (a->type)
875  {
876  case EXPR_NUM:
877  case EXPR_HEXNUM:
878  case EXPR_TRUEFALSE:
879  return a->u.lval - b->u.lval;
880  case EXPR_DOUBLE:
881  return a->u.dval - b->u.dval;
882  case EXPR_IDENTIFIER:
883  case EXPR_STRLIT:
884  case EXPR_WSTRLIT:
885  case EXPR_CHARCONST:
886  return strcmp(a->u.sval, b->u.sval);
887  case EXPR_COND:
888  ret = compare_expr(a->ref, b->ref);
889  if (ret != 0)
890  return ret;
891  ret = compare_expr(a->u.ext, b->u.ext);
892  if (ret != 0)
893  return ret;
894  return compare_expr(a->ext2, b->ext2);
895  case EXPR_OR:
896  case EXPR_AND:
897  case EXPR_ADD:
898  case EXPR_SUB:
899  case EXPR_MOD:
900  case EXPR_MUL:
901  case EXPR_DIV:
902  case EXPR_SHL:
903  case EXPR_SHR:
904  case EXPR_MEMBER:
905  case EXPR_ARRAY:
906  case EXPR_LOGOR:
907  case EXPR_LOGAND:
908  case EXPR_XOR:
909  case EXPR_EQUALITY:
910  case EXPR_INEQUALITY:
911  case EXPR_GTR:
912  case EXPR_LESS:
913  case EXPR_GTREQL:
914  case EXPR_LESSEQL:
915  ret = compare_expr(a->ref, b->ref);
916  if (ret != 0)
917  return ret;
918  return compare_expr(a->u.ext, b->u.ext);
919  case EXPR_CAST:
920  ret = compare_type(a->u.tref, b->u.tref);
921  if (ret != 0)
922  return ret;
923  /* Fall through. */
924  case EXPR_NOT:
925  case EXPR_NEG:
926  case EXPR_PPTR:
927  case EXPR_ADDRESSOF:
928  case EXPR_LOGNOT:
929  case EXPR_POS:
930  return compare_expr(a->ref, b->ref);
931  case EXPR_SIZEOF:
932  return compare_type(a->u.tref, b->u.tref);
933  case EXPR_VOID:
934  return 0;
935  }
936  return -1;
937 }
Definition: parse.h:56
static int compare_type(const type_t *a, const type_t *b)
Definition: expr.c:856
int compare_expr(const expr_t *a, const expr_t *b)
Definition: expr.c:867
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
int ret
Definition: parse.h:44
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
Definition: parse.h:48
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

Referenced by compare_expr(), and write_conf_or_var_desc().

◆ expr_resolve_type()

const type_t* expr_resolve_type ( const struct expr_loc expr_loc,
const type_t cont_type,
const expr_t expr 
)

Definition at line 684 of file expr.c.

685 {
686  struct expression_type expr_type;
687  expr_type = resolve_expression(expr_loc, cont_type, expr);
688  return expr_type.type;
689 }
expr_type
Definition: query.h:86
Definition: expr.h:22
static struct expression_type resolve_expression(const struct expr_loc *expr_loc, const type_t *cont_type, const expr_t *e)
Definition: expr.c:504

Referenced by check_conformance_expr_list(), check_field_common(), and write_conf_or_var_desc().

◆ make_expr()

expr_t* make_expr ( enum expr_type  type)

Definition at line 112 of file expr.c.

113 {
114  expr_t *e = xmalloc(sizeof(expr_t));
115  e->type = type;
116  e->ref = NULL;
117  e->u.lval = 0;
118  e->is_const = FALSE;
119  e->cval = 0;
120  return e;
121 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
smooth NULL
Definition: ftsmooth.c:416

Referenced by yyparse().

◆ make_expr1()

expr_t* make_expr1 ( enum expr_type  type,
expr_t expr 
)

Definition at line 251 of file expr.c.

252 {
253  expr_t *e;
254  e = xmalloc(sizeof(expr_t));
255  e->type = type;
256  e->ref = expr;
257  e->u.lval = 0;
258  e->is_const = FALSE;
259  /* check for compile-time optimization */
260  if (expr->is_const)
261  {
262  e->is_const = TRUE;
263  switch (type)
264  {
265  case EXPR_LOGNOT:
266  e->cval = !expr->cval;
267  break;
268  case EXPR_POS:
269  e->cval = +expr->cval;
270  break;
271  case EXPR_NEG:
272  e->cval = -expr->cval;
273  break;
274  case EXPR_NOT:
275  e->cval = ~expr->cval;
276  break;
277  default:
278  e->is_const = FALSE;
279  break;
280  }
281  }
282  return e;
283 }
#define TRUE
Definition: types.h:120
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
Definition: query.h:86
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
Definition: parse.h:44
Definition: parse.h:48

Referenced by yyparse().

◆ make_expr2()

expr_t* make_expr2 ( enum expr_type  type,
expr_t exp1,
expr_t exp2 
)

Definition at line 285 of file expr.c.

286 {
287  expr_t *e;
288  e = xmalloc(sizeof(expr_t));
289  e->type = type;
290  e->ref = expr1;
291  e->u.ext = expr2;
292  e->is_const = FALSE;
293  /* check for compile-time optimization */
294  if (expr1->is_const && expr2->is_const)
295  {
296  e->is_const = TRUE;
297  switch (type)
298  {
299  case EXPR_ADD:
300  e->cval = expr1->cval + expr2->cval;
301  break;
302  case EXPR_SUB:
303  e->cval = expr1->cval - expr2->cval;
304  break;
305  case EXPR_MOD:
306  if (expr2->cval == 0)
307  {
308  error_loc("divide by zero in expression\n");
309  e->cval = 0;
310  }
311  else
312  e->cval = expr1->cval % expr2->cval;
313  break;
314  case EXPR_MUL:
315  e->cval = expr1->cval * expr2->cval;
316  break;
317  case EXPR_DIV:
318  if (expr2->cval == 0)
319  {
320  error_loc("divide by zero in expression\n");
321  e->cval = 0;
322  }
323  else
324  e->cval = expr1->cval / expr2->cval;
325  break;
326  case EXPR_OR:
327  e->cval = expr1->cval | expr2->cval;
328  break;
329  case EXPR_AND:
330  e->cval = expr1->cval & expr2->cval;
331  break;
332  case EXPR_SHL:
333  e->cval = expr1->cval << expr2->cval;
334  break;
335  case EXPR_SHR:
336  e->cval = expr1->cval >> expr2->cval;
337  break;
338  case EXPR_LOGOR:
339  e->cval = expr1->cval || expr2->cval;
340  break;
341  case EXPR_LOGAND:
342  e->cval = expr1->cval && expr2->cval;
343  break;
344  case EXPR_XOR:
345  e->cval = expr1->cval ^ expr2->cval;
346  break;
347  case EXPR_EQUALITY:
348  e->cval = expr1->cval == expr2->cval;
349  break;
350  case EXPR_INEQUALITY:
351  e->cval = expr1->cval != expr2->cval;
352  break;
353  case EXPR_GTR:
354  e->cval = expr1->cval > expr2->cval;
355  break;
356  case EXPR_LESS:
357  e->cval = expr1->cval < expr2->cval;
358  break;
359  case EXPR_GTREQL:
360  e->cval = expr1->cval >= expr2->cval;
361  break;
362  case EXPR_LESSEQL:
363  e->cval = expr1->cval <= expr2->cval;
364  break;
365  default:
366  e->is_const = FALSE;
367  break;
368  }
369  }
370  return e;
371 }
Definition: parse.h:56
#define TRUE
Definition: types.h:120
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
void error_loc(const char *s,...)
Definition: utils.c:69

Referenced by yyparse().

◆ make_expr3()

expr_t* make_expr3 ( enum expr_type  type,
expr_t expr1,
expr_t expr2,
expr_t expr3 
)

Definition at line 373 of file expr.c.

374 {
375  expr_t *e;
376  e = xmalloc(sizeof(expr_t));
377  e->type = type;
378  e->ref = expr1;
379  e->u.ext = expr2;
380  e->ext2 = expr3;
381  e->is_const = FALSE;
382  /* check for compile-time optimization */
383  if (expr1->is_const && expr2->is_const && expr3->is_const)
384  {
385  e->is_const = TRUE;
386  switch (type)
387  {
388  case EXPR_COND:
389  e->cval = expr1->cval ? expr2->cval : expr3->cval;
390  break;
391  default:
392  e->is_const = FALSE;
393  break;
394  }
395  }
396  return e;
397 }
#define TRUE
Definition: types.h:120
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
int is_const
Definition: widltypes.h:317
void * xmalloc(int size)
Definition: uimain.c:747
int cval
Definition: widltypes.h:318
#define e
Definition: ke_i.h:82

Referenced by yyparse().

◆ make_exprd()

expr_t* make_exprd ( enum expr_type  type,
double  val 
)

Definition at line 141 of file expr.c.

142 {
143  expr_t *e = xmalloc(sizeof(expr_t));
144  e->type = type;
145  e->ref = NULL;
146  e->u.dval = val;
147  e->is_const = TRUE;
148  e->cval = val;
149  return e;
150 }
#define TRUE
Definition: types.h:120
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
smooth NULL
Definition: ftsmooth.c:416
GLuint GLfloat * val
Definition: glext.h:7180

Referenced by yyparse().

◆ make_exprl()

expr_t* make_exprl ( enum expr_type  type,
int  val 
)

Definition at line 123 of file expr.c.

124 {
125  expr_t *e = xmalloc(sizeof(expr_t));
126  e->type = type;
127  e->ref = NULL;
128  e->u.lval = val;
129  e->is_const = FALSE;
130  /* check for numeric constant */
131  if (type == EXPR_NUM || type == EXPR_HEXNUM || type == EXPR_TRUEFALSE)
132  {
133  /* make sure true/false value is valid */
134  assert(type != EXPR_TRUEFALSE || val == 0 || val == 1);
135  e->is_const = TRUE;
136  e->cval = val;
137  }
138  return e;
139 }
#define TRUE
Definition: types.h:120
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
smooth NULL
Definition: ftsmooth.c:416
GLuint GLfloat * val
Definition: glext.h:7180

Referenced by yyparse().

◆ make_exprs()

expr_t* make_exprs ( enum expr_type  type,
char val 
)

Definition at line 152 of file expr.c.

153 {
154  expr_t *e;
155  e = xmalloc(sizeof(expr_t));
156  e->type = type;
157  e->ref = NULL;
158  e->u.sval = val;
159  e->is_const = FALSE;
160  /* check for predefined constants */
161  switch (type)
162  {
163  case EXPR_IDENTIFIER:
164  {
165  var_t *c = find_const(val, 0);
166  if (c)
167  {
168  e->u.sval = c->name;
169  free(val);
170  e->is_const = TRUE;
171  e->cval = c->eval->cval;
172  }
173  break;
174  }
175  case EXPR_CHARCONST:
176  if (!val[0])
177  error_loc("empty character constant\n");
178  else if (val[1])
179  error_loc("multi-character constants are endian dependent\n");
180  else
181  {
182  e->is_const = TRUE;
183  e->cval = *val;
184  }
185  break;
186  default:
187  break;
188  }
189  return e;
190 }
char * name
Definition: wpp.c:36
#define TRUE
Definition: types.h:120
#define free
Definition: debug_ros.c:5
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
GLuint GLfloat * val
Definition: glext.h:7180
var_t * find_const(const char *name, int f)
Definition: parser.tab.c:6224
const GLubyte * c
Definition: glext.h:8905

Referenced by yyparse().

◆ make_exprt()

expr_t* make_exprt ( enum expr_type  type,
var_t var,
expr_t expr 
)

Definition at line 192 of file expr.c.

193 {
194  expr_t *e;
195  type_t *tref;
196 
197  if (var->stgclass != STG_NONE && var->stgclass != STG_REGISTER)
198  error_loc("invalid storage class for type expression\n");
199 
200  tref = var->type;
201 
202  e = xmalloc(sizeof(expr_t));
203  e->type = type;
204  e->ref = expr;
205  e->u.tref = tref;
206  e->is_const = FALSE;
207  if (type == EXPR_SIZEOF)
208  {
209  /* only do this for types that should be the same on all platforms */
210  if (is_integer_type(tref) || is_float_type(tref))
211  {
212  e->is_const = TRUE;
213  e->cval = type_memsize(tref);
214  }
215  }
216  /* check for cast of constant expression */
217  if (type == EXPR_CAST && expr->is_const)
218  {
219  if (is_integer_type(tref))
220  {
221  unsigned int cast_type_bits = type_memsize(tref) * 8;
222  unsigned int cast_mask;
223 
224  e->is_const = TRUE;
225  if (is_signed_integer_type(tref))
226  {
227  cast_mask = (1u << (cast_type_bits - 1)) - 1;
228  if (expr->cval & (1u << (cast_type_bits - 1)))
229  e->cval = -((-expr->cval) & cast_mask);
230  else
231  e->cval = expr->cval & cast_mask;
232  }
233  else
234  {
235  /* calculate ((1 << cast_type_bits) - 1) avoiding overflow */
236  cast_mask = ((1u << (cast_type_bits - 1)) - 1) |
237  1u << (cast_type_bits - 1);
238  e->cval = expr->cval & cast_mask;
239  }
240  }
241  else
242  {
243  e->is_const = TRUE;
244  e->cval = expr->cval;
245  }
246  }
247  free(var);
248  return e;
249 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define TRUE
Definition: types.h:120
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
#define free
Definition: debug_ros.c:5
static int is_signed_integer_type(const type_t *type)
Definition: expr.c:71
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
enum storage_class stgclass
Definition: widltypes.h:455
Definition: query.h:86
static int is_float_type(const type_t *type)
Definition: expr.c:105
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82
static int is_integer_type(const type_t *type)
Definition: expr.c:38
void error_loc(const char *s,...)
Definition: utils.c:69
type_t * type
Definition: widltypes.h:452
static unsigned int type_memsize(ITypeInfo *typeinfo, TYPEDESC *desc)
Definition: ndr_typelib.c:136

Referenced by yyparse().

◆ write_expr()

void write_expr ( FILE h,
const expr_t e,
int  brackets,
int  toplevel,
const char toplevel_prefix,
const type_t cont_type,
const char local_var_prefix 
)

Definition at line 691 of file expr.c.

694 {
695  switch (e->type)
696  {
697  case EXPR_VOID:
698  break;
699  case EXPR_NUM:
700  fprintf(h, "%u", e->u.lval);
701  break;
702  case EXPR_HEXNUM:
703  fprintf(h, "0x%x", e->u.lval);
704  break;
705  case EXPR_DOUBLE:
706  fprintf(h, "%#.15g", e->u.dval);
707  break;
708  case EXPR_TRUEFALSE:
709  if (e->u.lval == 0)
710  fprintf(h, "FALSE");
711  else
712  fprintf(h, "TRUE");
713  break;
714  case EXPR_IDENTIFIER:
715  if (toplevel && toplevel_prefix && cont_type)
716  {
717  int found_in_cont_type;
718  find_identifier(e->u.sval, cont_type, &found_in_cont_type);
719  if (found_in_cont_type)
720  {
721  fprintf(h, "%s%s", toplevel_prefix, e->u.sval);
722  break;
723  }
724  }
725  fprintf(h, "%s%s", local_var_prefix, e->u.sval);
726  break;
727  case EXPR_STRLIT:
728  fprintf(h, "\"%s\"", e->u.sval);
729  break;
730  case EXPR_WSTRLIT:
731  fprintf(h, "L\"%s\"", e->u.sval);
732  break;
733  case EXPR_CHARCONST:
734  fprintf(h, "'%s'", e->u.sval);
735  break;
736  case EXPR_LOGNOT:
737  fprintf(h, "!");
738  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
739  break;
740  case EXPR_NOT:
741  fprintf(h, "~");
742  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
743  break;
744  case EXPR_POS:
745  fprintf(h, "+");
746  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
747  break;
748  case EXPR_NEG:
749  fprintf(h, "-");
750  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
751  break;
752  case EXPR_ADDRESSOF:
753  fprintf(h, "&");
754  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
755  break;
756  case EXPR_PPTR:
757  fprintf(h, "*");
758  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
759  break;
760  case EXPR_CAST:
761  fprintf(h, "(");
762  write_type_decl(h, e->u.tref, NULL);
763  fprintf(h, ")");
764  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
765  break;
766  case EXPR_SIZEOF:
767  fprintf(h, "sizeof(");
768  write_type_decl(h, e->u.tref, NULL);
769  fprintf(h, ")");
770  break;
771  case EXPR_SHL:
772  case EXPR_SHR:
773  case EXPR_MOD:
774  case EXPR_MUL:
775  case EXPR_DIV:
776  case EXPR_ADD:
777  case EXPR_SUB:
778  case EXPR_AND:
779  case EXPR_OR:
780  case EXPR_LOGOR:
781  case EXPR_LOGAND:
782  case EXPR_XOR:
783  case EXPR_EQUALITY:
784  case EXPR_INEQUALITY:
785  case EXPR_GTR:
786  case EXPR_LESS:
787  case EXPR_GTREQL:
788  case EXPR_LESSEQL:
789  if (brackets) fprintf(h, "(");
790  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
791  switch (e->type)
792  {
793  case EXPR_SHL: fprintf(h, " << "); break;
794  case EXPR_SHR: fprintf(h, " >> "); break;
795  case EXPR_MOD: fprintf(h, " %% "); break;
796  case EXPR_MUL: fprintf(h, " * "); break;
797  case EXPR_DIV: fprintf(h, " / "); break;
798  case EXPR_ADD: fprintf(h, " + "); break;
799  case EXPR_SUB: fprintf(h, " - "); break;
800  case EXPR_AND: fprintf(h, " & "); break;
801  case EXPR_OR: fprintf(h, " | "); break;
802  case EXPR_LOGOR: fprintf(h, " || "); break;
803  case EXPR_LOGAND: fprintf(h, " && "); break;
804  case EXPR_XOR: fprintf(h, " ^ "); break;
805  case EXPR_EQUALITY: fprintf(h, " == "); break;
806  case EXPR_INEQUALITY: fprintf(h, " != "); break;
807  case EXPR_GTR: fprintf(h, " > "); break;
808  case EXPR_LESS: fprintf(h, " < "); break;
809  case EXPR_GTREQL: fprintf(h, " >= "); break;
810  case EXPR_LESSEQL: fprintf(h, " <= "); break;
811  default: break;
812  }
813  write_expr(h, e->u.ext, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
814  if (brackets) fprintf(h, ")");
815  break;
816  case EXPR_MEMBER:
817  if (brackets) fprintf(h, "(");
818  if (e->ref->type == EXPR_PPTR)
819  {
820  write_expr(h, e->ref->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
821  fprintf(h, "->");
822  }
823  else
824  {
825  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
826  fprintf(h, ".");
827  }
828  write_expr(h, e->u.ext, 1, 0, toplevel_prefix, cont_type, "");
829  if (brackets) fprintf(h, ")");
830  break;
831  case EXPR_COND:
832  if (brackets) fprintf(h, "(");
833  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
834  fprintf(h, " ? ");
835  write_expr(h, e->u.ext, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
836  fprintf(h, " : ");
837  write_expr(h, e->ext2, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
838  if (brackets) fprintf(h, ")");
839  break;
840  case EXPR_ARRAY:
841  if (brackets) fprintf(h, "(");
842  write_expr(h, e->ref, 1, toplevel, toplevel_prefix, cont_type, local_var_prefix);
843  fprintf(h, "[");
844  write_expr(h, e->u.ext, 1, 1, toplevel_prefix, cont_type, local_var_prefix);
845  fprintf(h, "]");
846  if (brackets) fprintf(h, ")");
847  break;
848  }
849 }
Definition: parse.h:56
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define e
Definition: ke_i.h:82
jmp_buf toplevel
Definition: main.c:95
smooth NULL
Definition: ftsmooth.c:416
static type_t * find_identifier(const char *identifier, const type_t *cont_type, int *found_in_cont_type)
Definition: expr.c:434
void write_type_decl(FILE *f, type_t *t, const char *name)
Definition: header.c:561
void write_expr(FILE *h, const expr_t *e, int brackets, int toplevel, const char *toplevel_prefix, const type_t *cont_type, const char *local_var_prefix)
Definition: expr.c:691
Definition: parse.h:44
Definition: parse.h:48

Referenced by assign_stub_out_args(), clear_output_vars(), write_args(), write_declaration(), write_enums(), write_expr(), write_expr_eval_routines(), and write_parameter_conf_or_var_exprs().