ReactOS 0.4.15-dev-8408-g466a198
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}
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().

◆ 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: expr.h:23
Definition: query.h:87
expr_type

Referenced by 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}
void * xmalloc(int size)
Definition: uimain.c:747
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#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}
#define TRUE
Definition: types.h:120

◆ 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}
void error_loc(const char *s,...)
Definition: utils.c:69

◆ 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}
int is_const
Definition: widltypes.h:318
int cval
Definition: widltypes.h:319

◆ 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}
#define assert(x)
Definition: debug.h:53

◆ 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
var_t * find_const(const char *name, int f)

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

◆ 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
static type_t * find_identifier(const char *identifier, const type_t *cont_type, int *found_in_cont_type)
Definition: expr.c:434
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().