Lines Matching refs:token
39 #include "token.h"
63 static struct token *comma_expression(struct token *, struct expression **);
65 struct token *parens_expression(struct token *token, struct expression **expr, const char *where)
67 struct token *p;
69 token = expect(token, '(', where);
70 p = token;
71 if (match_op(token, '{')) {
72 struct expression *e = alloc_expression(token->pos, EXPR_STATEMENT);
73 struct statement *stmt = alloc_statement(token->pos, STMT_COMPOUND);
77 token = compound_statement(token->next, stmt);
79 token = expect(token, '}', "at end of statement expression");
81 token = parse_expression(token, expr);
83 if (token == p)
84 sparse_error(token->pos, "an expression is expected before ')'");
85 return expect(token, ')', where);
88 struct token *string_expression(struct token *token, struct expression **expr, const char *where)
90 struct token *next = primary_expression(token, expr);
93 sparse_error(token->pos, "string literal expected for %s", where);
100 * Handle __func__, __FUNCTION__ and __PRETTY_FUNCTION__ token
103 static struct symbol *handle_func(struct token *token)
105 struct ident *ident = token->ident;
119 array = alloc_symbol(token->pos, SYM_ARRAY);
122 array->endpos = token->pos;
123 decl = alloc_symbol(token->pos, SYM_NODE);
127 decl->endpos = token->pos;
138 decl->initializer = alloc_expression(token->pos, EXPR_STRING);
141 decl->array_size = alloc_const_expression(token->pos, len + 1);
148 static struct token *parse_type(struct token *token, struct expression **tree)
151 *tree = alloc_expression(token->pos, EXPR_TYPE);
152 token = typename(token, &sym, NULL);
154 sparse_error(token->pos,
158 return token;
161 static struct token *builtin_types_compatible_p_expr(struct token *token,
165 token->pos, EXPR_COMPARE);
167 token = token->next;
168 if (!match_op(token, '('))
169 return expect(token, '(',
171 token = token->next;
172 token = parse_type(token, &expr->left);
173 if (!match_op(token, ','))
174 return expect(token, ',',
176 token = token->next;
177 token = parse_type(token, &expr->right);
178 if (!match_op(token, ')'))
179 return expect(token, ')',
181 token = token->next;
184 return token;
187 static struct token *builtin_offsetof_expr(struct token *token,
195 token = token->next;
196 if (!match_op(token, '('))
197 return expect(token, '(', "after __builtin_offset");
199 token = token->next;
200 token = typename(token, &sym, NULL);
202 sparse_error(token->pos,
206 if (!match_op(token, ','))
207 return expect(token, ',', "in __builtin_offset");
216 return expect(token, ')', "at end of __builtin_offset");
218 e = alloc_expression(token->pos, EXPR_OFFSETOF);
224 token = token->next;
225 e = alloc_expression(token->pos, EXPR_OFFSETOF);
227 if (token_type(token) != TOKEN_IDENT) {
228 sparse_error(token->pos, "Expected member name");
229 return token;
231 e->ident = token->ident;
232 token = token->next;
235 token = token->next;
236 e = alloc_expression(token->pos, EXPR_OFFSETOF);
238 token = parse_expression(token, &e->index);
239 token = expect(token, ']',
242 return token;
246 op = token_type(token) == TOKEN_SPECIAL ? token->special : 0;
261 static void get_number_value(struct expression *expr, struct token *token)
263 const char *str = token->number;
336 show_token(token));
341 show_token(token),
350 show_token(token));
358 show_token(token));
382 sparse_error(expr->pos, "constant %s is not a valid number", show_token(token));
388 static struct token *generic_selection(struct token *token, struct expression **tree)
390 struct expression *expr = alloc_expression(token->pos, EXPR_GENERIC);
393 token = expect(token, '(', "after '_Generic'");
394 token = assignment_expression(token, &expr->control);
395 if (!match_op(token, ',')) {
398 while (match_op(token, ',')) {
399 token = token->next;
400 if (lookup_type(token)) {
402 token = typename(token, &map->type, NULL);
403 token = expect(token, ':', "after typename");
404 token = assignment_expression(token, &map->expr);
407 } else if (match_ident(token, &default_ident)) {
409 warning(token->pos, "multiple default in generic expression");
412 token = token->next;
413 token = expect(token, ':', "after typename");
414 token = assignment_expression(token, &expr->def);
419 return expect(token, ')', "after expression");
422 struct token *primary_expression(struct token *token, struct expression **tree)
426 switch (token_type(token)) {
428 expr = alloc_expression(token->pos, EXPR_VALUE);
430 expr->ctype = token_type(token) < TOKEN_WIDE_CHAR ? &int_ctype : &long_ctype;
431 get_char_constant(token, &expr->value);
432 token = token->next;
436 expr = alloc_expression(token->pos, EXPR_VALUE);
437 get_number_value(expr, token); /* will see if it's an integer */
438 token = token->next;
442 expr = alloc_expression(token->pos, EXPR_SYMBOL);
446 expr->symbol_name = token->ident;
447 token = token->next;
452 struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
453 struct token *next = token->next;
456 sym = handle_func(token);
457 if (token->ident == &__builtin_types_compatible_p_ident) {
458 token = builtin_types_compatible_p_expr(token, &expr);
461 if (token->ident == &__builtin_offsetof_ident) {
462 token = builtin_offsetof_expr(token, &expr);
465 if (token->ident == &_Generic_ident) {
466 token = generic_selection(token->next, &expr);
470 expr = alloc_expression(token->pos, EXPR_VALUE);
473 expr->pos = token->pos;
475 token = next;
479 expr = alloc_expression(token->pos, EXPR_SYMBOL);
488 sparse_error(token->pos, "typename in expression");
491 expr->symbol_name = token->ident;
501 token = next;
507 expr = alloc_expression(token->pos, EXPR_STRING);
508 token = get_string_constant(token, expr);
512 if (token->special == '(') {
513 expr = alloc_expression(token->pos, EXPR_PREOP);
515 token = parens_expression(token, &expr->unop, "in expression");
518 if (token->special == '[' && lookup_type(token->next)) {
519 expr = alloc_expression(token->pos, EXPR_TYPE);
520 token = typename(token->next, &expr->symbol, NULL);
521 token = expect(token, ']', "in type expression");
529 return token;
532 static struct token *expression_list(struct token *token, struct expression_list **list)
534 while (!match_op(token, ')')) {
536 token = assignment_expression(token, &expr);
540 if (!match_op(token, ','))
542 token = token->next;
544 return token;
551 static struct token *postfix_expression(struct token *token, struct expression **tree, struct expression *cast_init_expr)
556 token = primary_expression(token, &expr);
558 while (expr && token_type(token) == TOKEN_SPECIAL) {
559 switch (token->special) {
561 struct expression *deref = alloc_expression(token->pos, EXPR_PREOP);
562 struct expression *add = alloc_expression(token->pos, EXPR_BINOP);
569 token = parse_expression(token->next, &add->right);
570 token = expect(token, ']', "at end of array dereference");
576 struct expression *post = alloc_expression(token->pos, EXPR_POSTOP);
577 post->op = token->special;
580 token = token->next;
585 struct expression *inner = alloc_expression(token->pos, EXPR_PREOP);
592 struct expression *deref = alloc_expression(token->pos, EXPR_DEREF);
595 token = token->next;
596 if (token_type(token) != TOKEN_IDENT) {
597 sparse_error(token->pos, "Expected member name");
600 deref->member = token->ident;
601 token = token->next;
607 struct expression *call = alloc_expression(token->pos, EXPR_CALL);
610 token = expression_list(token->next, &call->args);
611 token = expect(token, ')', "in function call");
622 return token;
625 static struct token *cast_expression(struct token *token, struct expression **tree);
626 static struct token *unary_expression(struct token *token, struct expression **tree);
628 static struct token *type_info_expression(struct token *token,
631 struct expression *expr = alloc_expression(token->pos, type);
632 struct token *p;
636 token = token->next;
637 if (!match_op(token, '(') || !lookup_type(token->next))
638 return unary_expression(token, &expr->cast_expression);
639 p = token;
640 token = typename(token->next, &expr->cast_type, NULL);
642 if (!match_op(token, ')')) {
648 return expect(token, ')', error[type]);
651 token = token->next;
656 if (match_op(token, '{')) {
661 token = initializer(&cast->cast_expression, token);
662 token = postfix_expression(token, &expr->cast_expression, cast);
664 return token;
667 static struct token *unary_expression(struct token *token, struct expression **tree)
669 if (token_type(token) == TOKEN_IDENT) {
670 struct ident *ident = token->ident;
685 return type_info_expression(token, tree, type_information[i].type);
690 if (token_type(token) == TOKEN_SPECIAL) {
691 if (match_oplist(token->special,
696 struct token *next;
698 next = cast_expression(token->next, &unop);
700 sparse_error(token->pos, "Syntax error in unary expression");
704 unary = alloc_expression(token->pos, EXPR_PREOP);
705 unary->op = token->special;
711 if (match_oplist(token->special, '+', '-', '~', '!', 0)) {
714 struct token *next;
716 next = cast_expression(token->next, &unop);
718 sparse_error(token->pos, "Syntax error in unary expression");
722 unary = alloc_expression(token->pos, EXPR_PREOP);
723 unary->op = token->special;
729 if (match_op(token, SPECIAL_LOGICAL_AND) &&
730 token_type(token->next) == TOKEN_IDENT) {
731 struct expression *label = alloc_expression(token->pos, EXPR_LABEL);
732 struct symbol *sym = label_symbol(token->next, 1);
737 check_label_usage(sym, token->pos);
741 return token->next->next;
746 return postfix_expression(token, tree, NULL);
757 static struct token *cast_expression(struct token *token, struct expression **tree)
759 if (match_op(token, '(')) {
760 struct token *next = token->next;
767 token = typename(next, &sym, &is_force);
769 token = expect(token, ')', "at end of cast operator");
770 if (match_op(token, '{')) {
776 token = initializer(&cast->cast_expression, token);
777 return postfix_expression(token, tree, cast);
782 token = cast_expression(token, &v);
784 return token;
786 return token;
789 return unary_expression(token, tree);
807 struct token * next = inner(__token, &left); \
832 static struct token *multiplicative_expression(struct token *token, struct expression **tree)
835 token, tree, EXPR_BINOP, cast_expression,
840 static struct token *additive_expression(struct token *token, struct expression **tree)
843 token, tree, EXPR_BINOP, multiplicative_expression,
848 static struct token *shift_expression(struct token *token, struct expression **tree)
851 token, tree, EXPR_BINOP, additive_expression,
856 static struct token *relational_expression(struct token *token, struct expression **tree)
859 token, tree, EXPR_COMPARE, shift_expression,
865 static struct token *equality_expression(struct token *token, struct expression **tree)
868 token, tree, EXPR_COMPARE, relational_expression,
873 static struct token *bitwise_and_expression(struct token *token, struct expression **tree)
876 token, tree, EXPR_BINOP, equality_expression,
881 static struct token *bitwise_xor_expression(struct token *token, struct expression **tree)
884 token, tree, EXPR_BINOP, bitwise_and_expression,
889 static struct token *bitwise_or_expression(struct token *token, struct expression **tree)
892 token, tree, EXPR_BINOP, bitwise_xor_expression,
897 static struct token *logical_and_expression(struct token *token, struct expression **tree)
900 token, tree, EXPR_LOGICAL, bitwise_or_expression,
905 static struct token *logical_or_expression(struct token *token, struct expression **tree)
908 token, tree, EXPR_LOGICAL, logical_and_expression,
913 struct token *conditional_expression(struct token *token, struct expression **tree)
915 token = logical_or_expression(token, tree);
916 if (*tree && match_op(token, '?')) {
917 struct expression *expr = alloc_expression(token->pos, EXPR_CONDITIONAL);
918 expr->op = token->special;
921 token = parse_expression(token->next, &expr->cond_true);
922 token = expect(token, ':', "in conditional expression");
923 token = conditional_expression(token, &expr->cond_false);
925 return token;
928 struct token *assignment_expression(struct token *token, struct expression **tree)
930 token = conditional_expression(token, tree);
931 if (*tree && token_type(token) == TOKEN_SPECIAL) {
939 int i, op = token->special;
942 struct expression * expr = alloc_expression(token->pos, EXPR_ASSIGNMENT);
943 struct token *next = token->next;
947 token = assignment_expression(next, &expr->right);
948 if (token == next)
949 expression_error(expr, "expression expected before '%s'", show_token(token));
950 return token;
953 return token;
956 static struct token *comma_expression(struct token *token, struct expression **tree)
959 token, tree, EXPR_COMMA, assignment_expression,
964 struct token *parse_expression(struct token *token, struct expression **tree)
966 return comma_expression(token,tree);