#endif
#include "adt/error.h"
+#include "adt/util.h"
struct obstack ast_obstack;
static unsigned get_expression_precedence(expression_kind_t kind)
{
static const unsigned prec[] = {
- [EXPR_UNKNOWN] = PREC_PRIMARY,
- [EXPR_INVALID] = PREC_PRIMARY,
- [EXPR_REFERENCE] = PREC_PRIMARY,
- [EXPR_REFERENCE_ENUM_VALUE] = PREC_PRIMARY,
- [EXPR_CHARACTER_CONSTANT] = PREC_PRIMARY,
- [EXPR_WIDE_CHARACTER_CONSTANT] = PREC_PRIMARY,
- [EXPR_CONST] = PREC_PRIMARY,
- [EXPR_STRING_LITERAL] = PREC_PRIMARY,
- [EXPR_WIDE_STRING_LITERAL] = PREC_PRIMARY,
- [EXPR_COMPOUND_LITERAL] = PREC_UNARY,
- [EXPR_CALL] = PREC_POSTFIX,
- [EXPR_CONDITIONAL] = PREC_CONDITIONAL,
- [EXPR_SELECT] = PREC_POSTFIX,
- [EXPR_ARRAY_ACCESS] = PREC_POSTFIX,
- [EXPR_SIZEOF] = PREC_UNARY,
- [EXPR_CLASSIFY_TYPE] = PREC_UNARY,
- [EXPR_ALIGNOF] = PREC_UNARY,
-
- [EXPR_FUNCNAME] = PREC_PRIMARY,
- [EXPR_BUILTIN_SYMBOL] = PREC_PRIMARY,
- [EXPR_BUILTIN_CONSTANT_P] = PREC_PRIMARY,
- [EXPR_BUILTIN_PREFETCH] = PREC_PRIMARY,
- [EXPR_OFFSETOF] = PREC_PRIMARY,
- [EXPR_VA_START] = PREC_PRIMARY,
- [EXPR_VA_ARG] = PREC_PRIMARY,
- [EXPR_STATEMENT] = PREC_PRIMARY,
- [EXPR_LABEL_ADDRESS] = PREC_PRIMARY,
-
- [EXPR_UNARY_NEGATE] = PREC_UNARY,
- [EXPR_UNARY_PLUS] = PREC_UNARY,
- [EXPR_UNARY_BITWISE_NEGATE] = PREC_UNARY,
- [EXPR_UNARY_NOT] = PREC_UNARY,
- [EXPR_UNARY_DEREFERENCE] = PREC_UNARY,
- [EXPR_UNARY_TAKE_ADDRESS] = PREC_UNARY,
- [EXPR_UNARY_POSTFIX_INCREMENT] = PREC_POSTFIX,
- [EXPR_UNARY_POSTFIX_DECREMENT] = PREC_POSTFIX,
- [EXPR_UNARY_PREFIX_INCREMENT] = PREC_UNARY,
- [EXPR_UNARY_PREFIX_DECREMENT] = PREC_UNARY,
- [EXPR_UNARY_CAST] = PREC_UNARY,
- [EXPR_UNARY_CAST_IMPLICIT] = PREC_UNARY,
- [EXPR_UNARY_ASSUME] = PREC_PRIMARY,
- [EXPR_UNARY_DELETE] = PREC_UNARY,
- [EXPR_UNARY_DELETE_ARRAY] = PREC_UNARY,
- [EXPR_UNARY_THROW] = PREC_ASSIGNMENT,
-
- [EXPR_BINARY_ADD] = PREC_ADDITIVE,
- [EXPR_BINARY_SUB] = PREC_ADDITIVE,
- [EXPR_BINARY_MUL] = PREC_MULTIPLICATIVE,
- [EXPR_BINARY_DIV] = PREC_MULTIPLICATIVE,
- [EXPR_BINARY_MOD] = PREC_MULTIPLICATIVE,
- [EXPR_BINARY_EQUAL] = PREC_EQUALITY,
- [EXPR_BINARY_NOTEQUAL] = PREC_EQUALITY,
- [EXPR_BINARY_LESS] = PREC_RELATIONAL,
- [EXPR_BINARY_LESSEQUAL] = PREC_RELATIONAL,
- [EXPR_BINARY_GREATER] = PREC_RELATIONAL,
- [EXPR_BINARY_GREATEREQUAL] = PREC_RELATIONAL,
- [EXPR_BINARY_BITWISE_AND] = PREC_AND,
- [EXPR_BINARY_BITWISE_OR] = PREC_OR,
- [EXPR_BINARY_BITWISE_XOR] = PREC_XOR,
- [EXPR_BINARY_LOGICAL_AND] = PREC_LOGICAL_AND,
- [EXPR_BINARY_LOGICAL_OR] = PREC_LOGICAL_OR,
- [EXPR_BINARY_SHIFTLEFT] = PREC_SHIFT,
- [EXPR_BINARY_SHIFTRIGHT] = PREC_SHIFT,
- [EXPR_BINARY_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_MUL_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_DIV_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_MOD_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_ADD_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_SUB_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_SHIFTLEFT_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_SHIFTRIGHT_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_BITWISE_AND_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_BITWISE_XOR_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_BITWISE_OR_ASSIGN] = PREC_ASSIGNMENT,
- [EXPR_BINARY_COMMA] = PREC_EXPRESSION,
-
- [EXPR_BINARY_ISGREATER] = PREC_PRIMARY,
- [EXPR_BINARY_ISGREATEREQUAL] = PREC_PRIMARY,
- [EXPR_BINARY_ISLESS] = PREC_PRIMARY,
- [EXPR_BINARY_ISLESSEQUAL] = PREC_PRIMARY,
- [EXPR_BINARY_ISLESSGREATER] = PREC_PRIMARY,
- [EXPR_BINARY_ISUNORDERED] = PREC_PRIMARY
+ [EXPR_UNKNOWN] = PREC_PRIMARY,
+ [EXPR_INVALID] = PREC_PRIMARY,
+ [EXPR_REFERENCE] = PREC_PRIMARY,
+ [EXPR_REFERENCE_ENUM_VALUE] = PREC_PRIMARY,
+ [EXPR_CHARACTER_CONSTANT] = PREC_PRIMARY,
+ [EXPR_WIDE_CHARACTER_CONSTANT] = PREC_PRIMARY,
+ [EXPR_CONST] = PREC_PRIMARY,
+ [EXPR_STRING_LITERAL] = PREC_PRIMARY,
+ [EXPR_WIDE_STRING_LITERAL] = PREC_PRIMARY,
+ [EXPR_COMPOUND_LITERAL] = PREC_UNARY,
+ [EXPR_CALL] = PREC_POSTFIX,
+ [EXPR_CONDITIONAL] = PREC_CONDITIONAL,
+ [EXPR_SELECT] = PREC_POSTFIX,
+ [EXPR_ARRAY_ACCESS] = PREC_POSTFIX,
+ [EXPR_SIZEOF] = PREC_UNARY,
+ [EXPR_CLASSIFY_TYPE] = PREC_UNARY,
+ [EXPR_ALIGNOF] = PREC_UNARY,
+
+ [EXPR_FUNCNAME] = PREC_PRIMARY,
+ [EXPR_BUILTIN_CONSTANT_P] = PREC_PRIMARY,
+ [EXPR_BUILTIN_TYPES_COMPATIBLE_P] = PREC_PRIMARY,
+ [EXPR_OFFSETOF] = PREC_PRIMARY,
+ [EXPR_VA_START] = PREC_PRIMARY,
+ [EXPR_VA_ARG] = PREC_PRIMARY,
+ [EXPR_VA_COPY] = PREC_PRIMARY,
+ [EXPR_STATEMENT] = PREC_PRIMARY,
+ [EXPR_LABEL_ADDRESS] = PREC_PRIMARY,
+
+ [EXPR_UNARY_NEGATE] = PREC_UNARY,
+ [EXPR_UNARY_PLUS] = PREC_UNARY,
+ [EXPR_UNARY_BITWISE_NEGATE] = PREC_UNARY,
+ [EXPR_UNARY_NOT] = PREC_UNARY,
+ [EXPR_UNARY_DEREFERENCE] = PREC_UNARY,
+ [EXPR_UNARY_TAKE_ADDRESS] = PREC_UNARY,
+ [EXPR_UNARY_POSTFIX_INCREMENT] = PREC_POSTFIX,
+ [EXPR_UNARY_POSTFIX_DECREMENT] = PREC_POSTFIX,
+ [EXPR_UNARY_PREFIX_INCREMENT] = PREC_UNARY,
+ [EXPR_UNARY_PREFIX_DECREMENT] = PREC_UNARY,
+ [EXPR_UNARY_CAST] = PREC_UNARY,
+ [EXPR_UNARY_CAST_IMPLICIT] = PREC_UNARY,
+ [EXPR_UNARY_ASSUME] = PREC_PRIMARY,
+ [EXPR_UNARY_DELETE] = PREC_UNARY,
+ [EXPR_UNARY_DELETE_ARRAY] = PREC_UNARY,
+ [EXPR_UNARY_THROW] = PREC_ASSIGNMENT,
+
+ [EXPR_BINARY_ADD] = PREC_ADDITIVE,
+ [EXPR_BINARY_SUB] = PREC_ADDITIVE,
+ [EXPR_BINARY_MUL] = PREC_MULTIPLICATIVE,
+ [EXPR_BINARY_DIV] = PREC_MULTIPLICATIVE,
+ [EXPR_BINARY_MOD] = PREC_MULTIPLICATIVE,
+ [EXPR_BINARY_EQUAL] = PREC_EQUALITY,
+ [EXPR_BINARY_NOTEQUAL] = PREC_EQUALITY,
+ [EXPR_BINARY_LESS] = PREC_RELATIONAL,
+ [EXPR_BINARY_LESSEQUAL] = PREC_RELATIONAL,
+ [EXPR_BINARY_GREATER] = PREC_RELATIONAL,
+ [EXPR_BINARY_GREATEREQUAL] = PREC_RELATIONAL,
+ [EXPR_BINARY_BITWISE_AND] = PREC_AND,
+ [EXPR_BINARY_BITWISE_OR] = PREC_OR,
+ [EXPR_BINARY_BITWISE_XOR] = PREC_XOR,
+ [EXPR_BINARY_LOGICAL_AND] = PREC_LOGICAL_AND,
+ [EXPR_BINARY_LOGICAL_OR] = PREC_LOGICAL_OR,
+ [EXPR_BINARY_SHIFTLEFT] = PREC_SHIFT,
+ [EXPR_BINARY_SHIFTRIGHT] = PREC_SHIFT,
+ [EXPR_BINARY_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_MUL_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_DIV_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_MOD_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_ADD_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_SUB_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_SHIFTLEFT_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_SHIFTRIGHT_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_BITWISE_AND_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_BITWISE_XOR_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_BITWISE_OR_ASSIGN] = PREC_ASSIGNMENT,
+ [EXPR_BINARY_COMMA] = PREC_EXPRESSION,
+
+ [EXPR_BINARY_ISGREATER] = PREC_PRIMARY,
+ [EXPR_BINARY_ISGREATEREQUAL] = PREC_PRIMARY,
+ [EXPR_BINARY_ISLESS] = PREC_PRIMARY,
+ [EXPR_BINARY_ISLESSEQUAL] = PREC_PRIMARY,
+ [EXPR_BINARY_ISLESSGREATER] = PREC_PRIMARY,
+ [EXPR_BINARY_ISUNORDERED] = PREC_PRIMARY
};
- assert((unsigned)kind < (sizeof(prec)/sizeof(prec[0])));
+ assert((size_t)kind < lengthof(prec));
unsigned res = prec[kind];
assert(res != PREC_BOTTOM);
fputc(border, out);
const char *end = string->begin + string->size - skip;
for (const char *c = string->begin; c != end; ++c) {
- if (*c == border) {
+ unsigned char const tc = *c;
+ if (tc == border) {
fputc('\\', out);
}
- switch (*c) {
+ switch (tc) {
case '\\': fputs("\\\\", out); break;
case '\a': fputs("\\a", out); break;
case '\b': fputs("\\b", out); break;
}
/* FALLTHROUGH */
default:
- if (!isprint(*c)) {
- fprintf(out, "\\%03o", (unsigned)(unsigned char)*c);
- break;
+ if (tc < 0x80 && !isprint(tc)) {
+ fprintf(out, "\\%03o", (unsigned)tc);
+ } else {
+ fputc(tc, out);
}
- fputc(*c, out);
break;
}
}
*/
static void print_call_expression(const call_expression_t *call)
{
- unsigned prec = get_expression_precedence(call->base.kind);
- print_expression_prec(call->function, prec);
+ print_expression_prec(call->function, PREC_POSTFIX);
fputc('(', out);
call_argument_t *argument = call->arguments;
int first = 1;
*/
static void print_array_expression(const array_access_expression_t *expression)
{
- unsigned prec = get_expression_precedence(expression->base.kind);
if (!expression->flipped) {
- print_expression_prec(expression->array_ref, prec);
+ print_expression_prec(expression->array_ref, PREC_POSTFIX);
fputc('[', out);
print_expression(expression->index);
fputc(']', out);
} else {
- print_expression_prec(expression->index, prec);
+ print_expression_prec(expression->index, PREC_POSTFIX);
fputc('[', out);
print_expression(expression->array_ref);
fputc(']', out);
fputs("__alignof__", out);
}
if (expression->tp_expression != NULL) {
- /* always print the '()' here, sizeof x is right but unusual */
- fputc('(', out);
- print_expression(expression->tp_expression);
- fputc(')', out);
+ /* PREC_TOP: always print the '()' here, sizeof x is right but unusual */
+ print_expression_prec(expression->tp_expression, PREC_TOP);
} else {
fputc('(', out);
print_type(expression->type);
}
}
-/**
- * Prints an builtin symbol.
- *
- * @param expression the builtin symbol expression
- */
-static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
-{
- fputs(expression->symbol->string, out);
-}
-
/**
* Prints a builtin constant expression.
*
}
/**
- * Prints a builtin prefetch expression.
+ * Prints a builtin types compatible expression.
*
- * @param expression the builtin prefetch expression
+ * @param expression the builtin types compatible expression
*/
-static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression)
+static void print_builtin_types_compatible(
+ const builtin_types_compatible_expression_t *expression)
{
- fputs("__builtin_prefetch(", out);
- print_assignment_expression(expression->adr);
- if (expression->rw) {
- fputc(',', out);
- print_assignment_expression(expression->rw);
- }
- if (expression->locality) {
- fputc(',', out);
- print_assignment_expression(expression->locality);
- }
+ fputs("__builtin_types_compatible_p(", out);
+ print_type(expression->left);
+ fputs(", ", out);
+ print_type(expression->right);
fputc(')', out);
}
static void print_conditional(const conditional_expression_t *expression)
{
print_expression_prec(expression->condition, PREC_LOGICAL_OR);
- fputs(" ? ", out);
if (expression->true_expression != NULL) {
+ fputs(" ? ", out);
print_expression_prec(expression->true_expression, PREC_EXPRESSION);
fputs(" : ", out);
} else {
- fputs(": ", out);
+ fputs(" ?: ", out);
}
precedence_t prec = c_mode & _CXX ? PREC_ASSIGNMENT : PREC_CONDITIONAL;
print_expression_prec(expression->false_expression, prec);
fputc(')', out);
}
+/**
+ * Prints a va_copy expression.
+ *
+ * @param expression the va_copy expression
+ */
+static void print_va_copy(const va_copy_expression_t *expression)
+{
+ fputs("__builtin_va_copy(", out);
+ print_assignment_expression(expression->dst);
+ fputs(", ", out);
+ print_assignment_expression(expression->src);
+ fputc(')', out);
+}
+
/**
* Prints a select expression (. or ->).
*
*/
static void print_select(const select_expression_t *expression)
{
- unsigned prec = get_expression_precedence(expression->base.kind);
- print_expression_prec(expression->compound, prec);
+ print_expression_prec(expression->compound, PREC_POSTFIX);
if (is_type_pointer(skip_typeref(expression->compound->base.type))) {
fputs("->", out);
} else {
*/
static void print_offsetof_expression(const offsetof_expression_t *expression)
{
- fputs("__builtin_offsetof", out);
- fputc('(', out);
+ fputs("__builtin_offsetof(", out);
print_type(expression->type);
fputc(',', out);
print_designator(expression->designator);
case EXPR_ALIGNOF:
print_typeprop_expression(&expression->typeprop);
break;
- case EXPR_BUILTIN_SYMBOL:
- print_builtin_symbol(&expression->builtin_symbol);
- break;
case EXPR_BUILTIN_CONSTANT_P:
print_builtin_constant(&expression->builtin_constant);
break;
- case EXPR_BUILTIN_PREFETCH:
- print_builtin_prefetch(&expression->builtin_prefetch);
+ case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
+ print_builtin_types_compatible(&expression->builtin_types_compatible);
break;
case EXPR_CONDITIONAL:
print_conditional(&expression->conditional);
case EXPR_VA_ARG:
print_va_arg(&expression->va_arge);
break;
+ case EXPR_VA_COPY:
+ print_va_copy(&expression->va_copye);
+ break;
case EXPR_SELECT:
print_select(&expression->select);
break;
static void print_for_statement(const for_statement_t *statement)
{
fputs("for (", out);
- entity_t *entity = statement->scope.entities;
- while (entity != NULL && is_generated_entity(entity))
- entity = entity->base.next;
-
- if (entity != NULL) {
- assert(statement->initialisation == NULL);
- assert(is_declaration(entity));
- print_declaration(entity);
- if (entity->base.next != NULL) {
- panic("multiple declarations in for statement not supported yet");
- }
+ if (statement->initialisation != NULL) {
+ print_expression(statement->initialisation);
+ fputc(';', out);
} else {
- if (statement->initialisation) {
- print_expression(statement->initialisation);
+ entity_t const *entity = statement->scope.entities;
+ for (; entity != NULL; entity = entity->base.next) {
+ if (is_generated_entity(entity))
+ continue;
+ /* FIXME display of multiple declarations is wrong */
+ print_declaration(entity);
}
- fputc(';', out);
}
if (statement->condition != NULL) {
fputc(' ', out);
panic("invalid initializer kind found");
}
+#if 0
/**
* Print microsoft extended declaration modifiers.
*/
if (ds_shown)
fputs(") ", out);
}
+#endif
static void print_scope(const scope_t *scope)
{
}
}
}
- print_ms_modifiers(declaration);
+ //print_ms_modifiers(declaration);
switch (entity->kind) {
case ENTITY_FUNCTION:
print_type_ext(entity->declaration.type, entity->base.symbol,
case ENTITY_VARIABLE:
case ENTITY_PARAMETER:
case ENTITY_COMPOUND_MEMBER:
- print_declaration(entity);
- return;
case ENTITY_FUNCTION:
print_declaration(entity);
return;
bool is_address_constant(const expression_t *expression)
{
switch (expression->kind) {
+ case EXPR_STRING_LITERAL:
+ case EXPR_WIDE_STRING_LITERAL:
+ case EXPR_FUNCNAME:
+ case EXPR_LABEL_ADDRESS:
+ return true;
+
case EXPR_UNARY_TAKE_ADDRESS:
return is_object_with_linker_constant_address(expression->unary.value);
}
}
+/**
+ * Check if the given expression is a call to a builtin function
+ * returning a constant result.
+ */
static bool is_builtin_const_call(const expression_t *expression)
{
expression_t *function = expression->call.function;
- if (function->kind != EXPR_BUILTIN_SYMBOL) {
+ if (function->kind != EXPR_REFERENCE)
+ return false;
+ reference_expression_t *ref = &function->reference;
+ if (ref->entity->kind != ENTITY_FUNCTION)
return false;
- }
-
- symbol_t *symbol = function->builtin_symbol.symbol;
- switch (symbol->ID) {
- case T___builtin_huge_val:
- case T___builtin_inf:
- case T___builtin_inff:
- case T___builtin_infl:
- case T___builtin_nan:
- case T___builtin_nanf:
- case T___builtin_nanl:
+ switch (ref->entity->function.btk) {
+ case bk_gnu_builtin_huge_val:
+ case bk_gnu_builtin_inf:
+ case bk_gnu_builtin_inff:
+ case bk_gnu_builtin_infl:
+ case bk_gnu_builtin_nan:
+ case bk_gnu_builtin_nanf:
+ case bk_gnu_builtin_nanl:
return true;
+ default:
+ return false;
}
- return false;
}
static bool is_constant_pointer(const expression_t *expression)
case EXPR_CONST:
case EXPR_CHARACTER_CONSTANT:
case EXPR_WIDE_CHARACTER_CONSTANT:
- case EXPR_STRING_LITERAL:
- case EXPR_WIDE_STRING_LITERAL:
case EXPR_CLASSIFY_TYPE:
- case EXPR_FUNCNAME:
case EXPR_OFFSETOF:
case EXPR_ALIGNOF:
case EXPR_BUILTIN_CONSTANT_P:
- case EXPR_LABEL_ADDRESS:
+ case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
case EXPR_REFERENCE_ENUM_VALUE:
return true;
return true;
}
- case EXPR_BUILTIN_SYMBOL:
- case EXPR_BUILTIN_PREFETCH:
+ case EXPR_STRING_LITERAL:
+ case EXPR_WIDE_STRING_LITERAL:
+ case EXPR_FUNCNAME:
+ case EXPR_LABEL_ADDRESS:
case EXPR_SELECT:
case EXPR_VA_START:
case EXPR_VA_ARG:
+ case EXPR_VA_COPY:
case EXPR_STATEMENT:
case EXPR_REFERENCE:
case EXPR_UNARY_POSTFIX_INCREMENT:
case EXPR_BINARY_BITWISE_AND:
case EXPR_BINARY_BITWISE_OR:
case EXPR_BINARY_BITWISE_XOR:
- case EXPR_BINARY_LOGICAL_AND:
- case EXPR_BINARY_LOGICAL_OR:
case EXPR_BINARY_SHIFTLEFT:
case EXPR_BINARY_SHIFTRIGHT:
case EXPR_BINARY_ISGREATER:
return is_constant_expression(expression->binary.left)
&& is_constant_expression(expression->binary.right);
+ case EXPR_BINARY_LOGICAL_AND: {
+ expression_t const *const left = expression->binary.left;
+ if (!is_constant_expression(left))
+ return false;
+ if (fold_constant(left) == 0)
+ return true;
+ return is_constant_expression(expression->binary.right);
+ }
+
+ case EXPR_BINARY_LOGICAL_OR: {
+ expression_t const *const left = expression->binary.left;
+ if (!is_constant_expression(left))
+ return false;
+ if (fold_constant(left) != 0)
+ return true;
+ return is_constant_expression(expression->binary.right);
+ }
+
case EXPR_COMPOUND_LITERAL:
return is_constant_initializer(expression->compound_literal.initializer);
return false;
long val = fold_constant(condition);
- if (val != 0)
- return is_constant_expression(expression->conditional.true_expression);
- else
+ if (val != 0) {
+ expression_t const *const t = expression->conditional.true_expression;
+ return t == NULL || is_constant_expression(t);
+ } else {
return is_constant_expression(expression->conditional.false_expression);
+ }
}
case EXPR_INVALID:
projects / cparser / blobdiff