ReactOS 0.4.15-dev-8222-g9164419
expr.c File Reference
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
#include "widl.h"
#include "utils.h"
#include "expr.h"
#include "header.h"
#include "typetree.h"
#include "typegen.h"
Include dependency graph for expr.c:

Go to the source code of this file.

Classes

struct  expression_type
 

Functions

static int is_integer_type (const type_t *type)
 
static int is_signed_integer_type (const type_t *type)
 
static int is_float_type (const type_t *type)
 
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 *expr1, expr_t *expr2)
 
expr_tmake_expr3 (enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3)
 
static void check_scalar_type (const struct expr_loc *expr_loc, const type_t *cont_type, const type_t *type)
 
static void check_arithmetic_type (const struct expr_loc *expr_loc, const type_t *cont_type, const type_t *type)
 
static void check_integer_type (const struct expr_loc *expr_loc, const type_t *cont_type, const type_t *type)
 
static type_tfind_identifier (const char *identifier, const type_t *cont_type, int *found_in_cont_type)
 
static int is_valid_member_operand (const type_t *type)
 
static struct expression_type resolve_expression (const struct expr_loc *expr_loc, const type_t *cont_type, const expr_t *e)
 
const type_texpr_resolve_type (const struct expr_loc *expr_loc, const type_t *cont_type, const expr_t *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)
 
static int compare_type (const type_t *a, const type_t *b)
 
int compare_expr (const expr_t *a, const expr_t *b)
 

Function Documentation

◆ check_arithmetic_type()

static void check_arithmetic_type ( const struct expr_loc expr_loc,
const type_t cont_type,
const type_t type 
)
static

Definition at line 416 of file expr.c.

418{
419 if (!cont_type || (!is_integer_type(type) && !is_float_type(type)))
420 error_loc_info(&expr_loc->v->loc_info, "arithmetic type required in expression%s%s\n",
421 expr_loc->attr ? " for attribute " : "",
422 expr_loc->attr ? expr_loc->attr : "");
423}
static int is_float_type(const type_t *type)
Definition: expr.c:105
static int is_integer_type(const type_t *type)
Definition: expr.c:38
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void error_loc_info(const loc_info_t *loc_info, const char *s,...)
Definition: utils.c:85
struct _loc_info_t loc_info
Definition: widltypes.h:460
Definition: expr.h:23
const var_t * v
Definition: expr.h:24
const char * attr
Definition: expr.h:25

Referenced by resolve_expression().

◆ check_integer_type()

static void check_integer_type ( const struct expr_loc expr_loc,
const type_t cont_type,
const type_t type 
)
static

Definition at line 425 of file expr.c.

427{
428 if (!cont_type || !is_integer_type(type))
429 error_loc_info(&expr_loc->v->loc_info, "integer type required in expression%s%s\n",
430 expr_loc->attr ? " for attribute " : "",
431 expr_loc->attr ? expr_loc->attr : "");
432}

Referenced by resolve_expression().

◆ check_scalar_type()

static void check_scalar_type ( const struct expr_loc expr_loc,
const type_t cont_type,
const type_t type 
)
static

Definition at line 406 of file expr.c.

408{
409 if (!cont_type || (!is_integer_type(type) && !is_ptr(type) &&
411 error_loc_info(&expr_loc->v->loc_info, "scalar type required in expression%s%s\n",
412 expr_loc->attr ? " for attribute " : "",
413 expr_loc->attr ? expr_loc->attr : "");
414}
static int is_ptr(const type_t *t)
Definition: header.h:59

Referenced by resolve_expression().

◆ 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}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
@ EXPR_MEMBER
Definition: parser.h:266
@ EXPR_LESS
Definition: parser.h:243
@ EXPR_ARRAY
Definition: parser.h:265
@ EXPR_MOD
Definition: parser.h:229
@ EXPR_VOID
Definition: parser.h:231
@ EXPR_DIV
Definition: parser.h:228
@ EXPR_ADD
Definition: parser.h:225
@ EXPR_MUL
Definition: parser.h:227
@ EXPR_COND
Definition: parser.h:264
@ EXPR_OR
Definition: parser.h:218
@ EXPR_SUB
Definition: parser.h:226
@ EXPR_AND
Definition: parser.h:219
@ EXPR_DOUBLE
Definition: parse.h:28
@ EXPR_NEG
Definition: parse.h:45
@ EXPR_NOT
Definition: parse.h:49
@ EXPR_XOR
Definition: parse.h:55
int compare_expr(const expr_t *a, const expr_t *b)
Definition: expr.c:867
static int compare_type(const type_t *a, const type_t *b)
Definition: expr.c:856
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
int ret
@ EXPR_CAST
Definition: widltypes.h:184
@ EXPR_HEXNUM
Definition: widltypes.h:178
@ EXPR_LOGOR
Definition: widltypes.h:200
@ EXPR_LOGAND
Definition: widltypes.h:201
@ EXPR_TRUEFALSE
Definition: widltypes.h:195
@ EXPR_CHARCONST
Definition: widltypes.h:213
@ EXPR_IDENTIFIER
Definition: widltypes.h:180
@ EXPR_SHR
Definition: widltypes.h:187
@ EXPR_LOGNOT
Definition: widltypes.h:209
@ EXPR_SHL
Definition: widltypes.h:186
@ EXPR_GTR
Definition: widltypes.h:205
@ EXPR_EQUALITY
Definition: widltypes.h:203
@ EXPR_INEQUALITY
Definition: widltypes.h:204
@ EXPR_POS
Definition: widltypes.h:210
@ EXPR_LESSEQL
Definition: widltypes.h:208
@ EXPR_WSTRLIT
Definition: widltypes.h:212
@ EXPR_STRLIT
Definition: widltypes.h:211
@ EXPR_NUM
Definition: widltypes.h:177
@ EXPR_PPTR
Definition: widltypes.h:183
@ EXPR_SIZEOF
Definition: widltypes.h:185
@ EXPR_GTREQL
Definition: widltypes.h:207
@ EXPR_ADDRESSOF
Definition: widltypes.h:196

Referenced by compare_expr(), and write_conf_or_var_desc().

◆ compare_type()

static int compare_type ( const type_t a,
const type_t b 
)
static

Definition at line 856 of file expr.c.

857{
858 if (a == b
859 || (a->name
860 && b->name
861 && strcmp(a->name, b->name) == 0))
862 return 0;
863 /* Ordering doesn't need to be implemented yet. */
864 return 1;
865}

Referenced by compare_expr().

◆ 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{
688 return expr_type.type;
689}
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
Definition: query.h:87
expr_type

Referenced by write_conf_or_var_desc().

◆ find_identifier()

static type_t * find_identifier ( const char identifier,
const type_t cont_type,
int found_in_cont_type 
)
static

Definition at line 434 of file expr.c.

435{
436 type_t *type = NULL;
437 const var_t *field;
438 const var_list_t *fields = NULL;
439
440 *found_in_cont_type = 0;
441
442 if (cont_type)
443 {
444 switch (type_get_type(cont_type))
445 {
446 case TYPE_FUNCTION:
447 fields = type_function_get_args(cont_type);
448 break;
449 case TYPE_STRUCT:
450 fields = type_struct_get_fields(cont_type);
451 break;
452 case TYPE_UNION:
454 fields = type_union_get_cases(cont_type);
455 break;
456 case TYPE_VOID:
457 case TYPE_BASIC:
458 case TYPE_ENUM:
459 case TYPE_MODULE:
460 case TYPE_COCLASS:
461 case TYPE_INTERFACE:
462 case TYPE_POINTER:
463 case TYPE_ARRAY:
464 case TYPE_BITFIELD:
465 /* nothing to do */
466 break;
467 case TYPE_ALIAS:
468 /* shouldn't get here because of using type_get_type above */
469 assert(0);
470 break;
471 }
472 }
473
475 if (field->name && !strcmp(identifier, field->name))
476 {
477 type = field->type;
478 *found_in_cont_type = 1;
479 break;
480 }
481
482 if (!type)
483 {
484 var_t *const_var = find_const(identifier, 0);
485 if (const_var) type = const_var->type;
486 }
487
488 return type;
489}
Definition: list.h:37
#define NULL
Definition: types.h:112
#define assert(x)
Definition: debug.h:53
uint32_t entry
Definition: isohybrid.c:63
const char * fields[10]
Definition: parser.c:313
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
type_t * type
Definition: widltypes.h:453
Definition: parser.c:44
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
static var_list_t * type_union_get_cases(const type_t *type)
Definition: typetree.h:134
static var_list_t * type_struct_get_fields(const type_t *type)
Definition: typetree.h:87
static var_list_t * type_function_get_args(const type_t *type)
Definition: typetree.h:94
@ TYPE_ENUM
Definition: widltypes.h:404
@ TYPE_BITFIELD
Definition: widltypes.h:415
@ TYPE_BASIC
Definition: widltypes.h:403
@ TYPE_UNION
Definition: widltypes.h:407
@ TYPE_ALIAS
Definition: widltypes.h:408
@ TYPE_POINTER
Definition: widltypes.h:413
@ TYPE_VOID
Definition: widltypes.h:402
@ TYPE_ENCAPSULATED_UNION
Definition: widltypes.h:406
@ TYPE_COCLASS
Definition: widltypes.h:410
@ TYPE_STRUCT
Definition: widltypes.h:405
@ TYPE_MODULE
Definition: widltypes.h:409
@ TYPE_INTERFACE
Definition: widltypes.h:412
@ TYPE_ARRAY
Definition: widltypes.h:414
@ TYPE_FUNCTION
Definition: widltypes.h:411
var_t * find_const(const char *name, int f)

Referenced by resolve_expression(), and write_expr().

◆ is_float_type()

static int is_float_type ( const type_t type)
static

Definition at line 105 of file expr.c.

106{
107 return (type_get_type(type) == TYPE_BASIC &&
110}
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
@ TYPE_BASIC_DOUBLE
Definition: widltypes.h:275
@ TYPE_BASIC_FLOAT
Definition: widltypes.h:274

Referenced by check_arithmetic_type(), check_scalar_type(), and make_exprt().

◆ is_integer_type()

static int is_integer_type ( const type_t type)
static

Definition at line 38 of file expr.c.

39{
40 switch (type_get_type(type))
41 {
42 case TYPE_ENUM:
43 return TRUE;
44 case TYPE_BASIC:
46 {
47 case TYPE_BASIC_INT8:
51 case TYPE_BASIC_INT:
53 case TYPE_BASIC_LONG:
54 case TYPE_BASIC_CHAR:
56 case TYPE_BASIC_BYTE:
59 return TRUE;
63 return FALSE;
64 }
65 return FALSE;
66 default:
67 return FALSE;
68 }
69}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
@ TYPE_BASIC_INT32
Definition: widltypes.h:265
@ TYPE_BASIC_ERROR_STATUS_T
Definition: widltypes.h:276
@ TYPE_BASIC_CHAR
Definition: widltypes.h:270
@ TYPE_BASIC_WCHAR
Definition: widltypes.h:273
@ TYPE_BASIC_INT16
Definition: widltypes.h:264
@ TYPE_BASIC_HYPER
Definition: widltypes.h:271
@ TYPE_BASIC_HANDLE
Definition: widltypes.h:277
@ TYPE_BASIC_INT8
Definition: widltypes.h:263
@ TYPE_BASIC_INT3264
Definition: widltypes.h:268
@ TYPE_BASIC_LONG
Definition: widltypes.h:269
@ TYPE_BASIC_INT64
Definition: widltypes.h:266
@ TYPE_BASIC_BYTE
Definition: widltypes.h:272
@ TYPE_BASIC_INT
Definition: widltypes.h:267

Referenced by check_arithmetic_type(), check_integer_type(), check_scalar_type(), make_exprt(), and resolve_expression().

◆ is_signed_integer_type()

static int is_signed_integer_type ( const type_t type)
static

Definition at line 71 of file expr.c.

72{
73 switch (type_get_type(type))
74 {
75 case TYPE_ENUM:
76 return FALSE;
77 case TYPE_BASIC:
79 {
80 case TYPE_BASIC_INT8:
84 case TYPE_BASIC_INT:
86 case TYPE_BASIC_LONG:
87 return type_basic_get_sign(type) < 0;
88 case TYPE_BASIC_CHAR:
89 return TRUE;
91 case TYPE_BASIC_BYTE:
97 return FALSE;
98 }
99 /* FALLTHROUGH */
100 default:
101 return FALSE;
102 }
103}
static int type_basic_get_sign(const type_t *type)
Definition: typetree.h:80

Referenced by make_exprt().

◆ is_valid_member_operand()

static int is_valid_member_operand ( const type_t type)
static

Definition at line 491 of file expr.c.

492{
493 switch (type_get_type(type))
494 {
495 case TYPE_STRUCT:
496 case TYPE_UNION:
497 case TYPE_ENUM:
498 return TRUE;
499 default:
500 return FALSE;
501 }
502}

Referenced by resolve_expression().

◆ 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}
void * xmalloc(int size)
Definition: uimain.c:747
#define e
Definition: ke_i.h:82

◆ 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}

◆ make_expr2()

expr_t * make_expr2 ( enum expr_type  type,
expr_t expr1,
expr_t expr2 
)

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}
void error_loc(const char *s,...)
Definition: utils.c:69
int is_const
Definition: widltypes.h:318
int cval
Definition: widltypes.h:319

◆ 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}

◆ 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}
GLuint GLfloat * val
Definition: glext.h:7180

◆ 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}

◆ 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}
#define free
Definition: debug_ros.c:5
const GLubyte * c
Definition: glext.h:8905
char * name
Definition: compiler.c:66

◆ 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}
static int is_signed_integer_type(const type_t *type)
Definition: expr.c:71
const char * var
Definition: shader.c:5666
static unsigned int type_memsize(ITypeInfo *typeinfo, TYPEDESC *desc)
Definition: ndr_typelib.c:152
@ STG_REGISTER
Definition: widltypes.h:235
@ STG_NONE
Definition: widltypes.h:232

◆ resolve_expression()

static struct expression_type resolve_expression ( const struct expr_loc expr_loc,
const type_t cont_type,
const expr_t e 
)
static

Definition at line 504 of file expr.c.

507{
508 struct expression_type result;
510 result.is_temporary = FALSE;
511 result.type = NULL;
512 switch (e->type)
513 {
514 case EXPR_VOID:
515 break;
516 case EXPR_HEXNUM:
517 case EXPR_NUM:
518 case EXPR_TRUEFALSE:
519 result.is_temporary = FALSE;
521 break;
522 case EXPR_STRLIT:
523 result.is_temporary = TRUE;
525 break;
526 case EXPR_WSTRLIT:
527 result.is_temporary = TRUE;
529 break;
530 case EXPR_CHARCONST:
531 result.is_temporary = TRUE;
533 break;
534 case EXPR_DOUBLE:
535 result.is_temporary = TRUE;
537 break;
538 case EXPR_IDENTIFIER:
539 {
540 int found_in_cont_type;
541 result.is_variable = TRUE;
542 result.is_temporary = FALSE;
543 result.type = find_identifier(e->u.sval, cont_type, &found_in_cont_type);
544 if (!result.type)
545 {
546 error_loc_info(&expr_loc->v->loc_info, "identifier %s cannot be resolved in expression%s%s\n",
547 e->u.sval, expr_loc->attr ? " for attribute " : "",
548 expr_loc->attr ? expr_loc->attr : "");
549 }
550 break;
551 }
552 case EXPR_LOGNOT:
553 result = resolve_expression(expr_loc, cont_type, e->ref);
554 check_scalar_type(expr_loc, cont_type, result.type);
555 result.is_variable = FALSE;
556 result.is_temporary = FALSE;
558 break;
559 case EXPR_NOT:
560 result = resolve_expression(expr_loc, cont_type, e->ref);
561 check_integer_type(expr_loc, cont_type, result.type);
562 result.is_variable = FALSE;
563 break;
564 case EXPR_POS:
565 case EXPR_NEG:
566 result = resolve_expression(expr_loc, cont_type, e->ref);
567 check_arithmetic_type(expr_loc, cont_type, result.type);
568 result.is_variable = FALSE;
569 break;
570 case EXPR_ADDRESSOF:
571 result = resolve_expression(expr_loc, cont_type, e->ref);
572 if (!result.is_variable)
573 error_loc_info(&expr_loc->v->loc_info, "address-of operator applied to non-variable type in expression%s%s\n",
574 expr_loc->attr ? " for attribute " : "",
575 expr_loc->attr ? expr_loc->attr : "");
576 result.is_variable = FALSE;
577 result.is_temporary = TRUE;
578 result.type = type_new_pointer(FC_UP, result.type, NULL);
579 break;
580 case EXPR_PPTR:
581 result = resolve_expression(expr_loc, cont_type, e->ref);
582 if (result.type && is_ptr(result.type))
584 else if(result.type && is_array(result.type)
587 else
588 error_loc_info(&expr_loc->v->loc_info, "dereference operator applied to non-pointer type in expression%s%s\n",
589 expr_loc->attr ? " for attribute " : "",
590 expr_loc->attr ? expr_loc->attr : "");
591 break;
592 case EXPR_CAST:
593 result = resolve_expression(expr_loc, cont_type, e->ref);
594 result.type = e->u.tref;
595 break;
596 case EXPR_SIZEOF:
597 result.is_temporary = FALSE;
599 break;
600 case EXPR_SHL:
601 case EXPR_SHR:
602 case EXPR_MOD:
603 case EXPR_MUL:
604 case EXPR_DIV:
605 case EXPR_ADD:
606 case EXPR_SUB:
607 case EXPR_AND:
608 case EXPR_OR:
609 case EXPR_XOR:
610 {
611 struct expression_type result_right;
612 result = resolve_expression(expr_loc, cont_type, e->ref);
613 result.is_variable = FALSE;
614 result_right = resolve_expression(expr_loc, cont_type, e->u.ext);
615 /* FIXME: these checks aren't strict enough for some of the operators */
616 check_scalar_type(expr_loc, cont_type, result.type);
617 check_scalar_type(expr_loc, cont_type, result_right.type);
618 break;
619 }
620 case EXPR_LOGOR:
621 case EXPR_LOGAND:
622 case EXPR_EQUALITY:
623 case EXPR_INEQUALITY:
624 case EXPR_GTR:
625 case EXPR_LESS:
626 case EXPR_GTREQL:
627 case EXPR_LESSEQL:
628 {
629 struct expression_type result_left, result_right;
630 result_left = resolve_expression(expr_loc, cont_type, e->ref);
631 result_right = resolve_expression(expr_loc, cont_type, e->u.ext);
632 check_scalar_type(expr_loc, cont_type, result_left.type);
633 check_scalar_type(expr_loc, cont_type, result_right.type);
634 result.is_temporary = FALSE;
636 break;
637 }
638 case EXPR_MEMBER:
639 result = resolve_expression(expr_loc, cont_type, e->ref);
640 if (result.type && is_valid_member_operand(result.type))
641 result = resolve_expression(expr_loc, result.type, e->u.ext);
642 else
643 error_loc_info(&expr_loc->v->loc_info, "'.' or '->' operator applied to a type that isn't a structure, union or enumeration in expression%s%s\n",
644 expr_loc->attr ? " for attribute " : "",
645 expr_loc->attr ? expr_loc->attr : "");
646 break;
647 case EXPR_COND:
648 {
649 struct expression_type result_first, result_second, result_third;
650 result_first = resolve_expression(expr_loc, cont_type, e->ref);
651 check_scalar_type(expr_loc, cont_type, result_first.type);
652 result_second = resolve_expression(expr_loc, cont_type, e->u.ext);
653 result_third = resolve_expression(expr_loc, cont_type, e->ext2);
654 check_scalar_type(expr_loc, cont_type, result_second.type);
655 check_scalar_type(expr_loc, cont_type, result_third.type);
656 if (!is_ptr(result_second.type) ^ !is_ptr(result_third.type))
657 error_loc_info(&expr_loc->v->loc_info, "type mismatch in ?: expression\n" );
658 /* FIXME: determine the correct return type */
659 result = result_second;
660 result.is_variable = FALSE;
661 break;
662 }
663 case EXPR_ARRAY:
664 result = resolve_expression(expr_loc, cont_type, e->ref);
665 if (result.type && is_array(result.type))
666 {
667 struct expression_type index_result;
669 index_result = resolve_expression(expr_loc, cont_type /* FIXME */, e->u.ext);
670 if (!index_result.type || !is_integer_type(index_result.type))
671 error_loc_info(&expr_loc->v->loc_info, "array subscript not of integral type in expression%s%s\n",
672 expr_loc->attr ? " for attribute " : "",
673 expr_loc->attr ? expr_loc->attr : "");
674 }
675 else
676 error_loc_info(&expr_loc->v->loc_info, "array subscript operator applied to non-array type in expression%s%s\n",
677 expr_loc->attr ? " for attribute " : "",
678 expr_loc->attr ? expr_loc->attr : "");
679 break;
680 }
681 return result;
682}
static void check_integer_type(const struct expr_loc *expr_loc, const type_t *cont_type, const type_t *type)
Definition: expr.c:425
static void check_scalar_type(const struct expr_loc *expr_loc, const type_t *cont_type, const type_t *type)
Definition: expr.c:406
static void check_arithmetic_type(const struct expr_loc *expr_loc, const type_t *cont_type, const type_t *type)
Definition: expr.c:416
static int is_valid_member_operand(const type_t *type)
Definition: expr.c:491
static type_t * find_identifier(const char *identifier, const type_t *cont_type, int *found_in_cont_type)
Definition: expr.c:434
GLuint64EXT * result
Definition: glext.h:11304
static int is_array(const type_t *t)
Definition: header.h:64
@ FC_UP
Definition: ndrtypes.h:153
type_t * type
Definition: expr.c:403
int is_variable
Definition: expr.c:401
type_t * type_new_basic(enum type_basic_type basic_type)
Definition: typetree.c:243
type_t * type_new_pointer(unsigned char pointer_default, type_t *ref, attr_list_t *attrs)
Definition: typetree.c:181
type_t * type_new_int(enum type_basic_type basic_type, int sign)
Definition: typetree.c:251
static int type_array_is_decl_as_ptr(const type_t *type)
Definition: typetree.h:260
static type_t * type_array_get_element(const type_t *type)
Definition: typetree.h:253
static type_t * type_pointer_get_ref(const type_t *type)
Definition: typetree.h:292

Referenced by expr_resolve_type(), and resolve_expression().

◆ 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}
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
jmp_buf toplevel
Definition: main.c:95
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,...)
void write_type_decl(FILE *f, type_t *t, const char *name)
Definition: header.c:561

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().