Lines Matching defs:flags
65 bc_parse_expr_err(BcParse* p, uint8_t flags, BcParseNext next);
68 bc_parse_expr_status(BcParse* p, uint8_t flags, BcParseNext next);
110 uint16_t *fptr = NULL, flags = BC_PARSE_FLAG_ELSE;
113 for (i = 0; i < p->flags.len && BC_PARSE_BLOCK_STMT(flags); ++i)
115 fptr = bc_vec_item_rev(&p->flags, i);
116 flags = *fptr;
120 if ((flags & BC_PARSE_FLAG_BRACE) && p->l.last != BC_LEX_RBRACE)
127 good = ((flags & BC_PARSE_FLAG_IF) != 0);
134 for (i = 0; !good && i < p->flags.len; ++i)
136 uint16_t* fptr = bc_vec_item_rev(&p->flags, i);
154 bool good = p->flags.len == 2;
321 * @param flags Flags restricting what kind of expressions the arguments can
325 bc_parse_args(BcParse* p, uint8_t flags)
334 flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
335 flags |= (BC_PARSE_ARRAY | BC_PARSE_NEEDVAL);
340 bc_parse_expr_status(p, flags, bc_parse_next_arg);
357 * @param flags Flags restricting what kind of expressions the arguments can
361 bc_parse_call(BcParse* p, const char* name, uint8_t flags)
365 bc_parse_args(p, flags);
402 * @param flags Flags restricting what kind of expression the name can be.
405 bc_parse_name(BcParse* p, BcInst* type, bool* can_assign, uint8_t flags)
428 if (BC_ERR(!(flags & BC_PARSE_ARRAY)))
439 // expression parsing flags.
440 uint8_t flags2 = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) |
465 if (BC_ERR(flags & BC_PARSE_NOCALL))
473 bc_parse_call(p, name, flags);
518 * @param flags The expression parsing flags for parsing the argument.
522 bc_parse_builtin(BcParse* p, BcLexType type, uint8_t flags, BcInst* prev)
530 // Change the flags as needed for parsing the argument.
531 flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
532 flags |= BC_PARSE_NEEDVAL;
537 flags |= BC_PARSE_ARRAY;
541 else flags &= ~(BC_PARSE_ARRAY);
543 bc_parse_expr_status(p, flags, bc_parse_next_rel);
560 * @param flags The expression parsing flags for parsing the argument.
564 bc_parse_builtin3(BcParse* p, BcLexType type, uint8_t flags, BcInst* prev)
574 // Change the flags as needed for parsing the argument.
575 flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
576 flags |= BC_PARSE_NEEDVAL;
578 bc_parse_expr_status(p, flags, bc_parse_next_builtin);
585 bc_parse_expr_status(p, flags, bc_parse_next_builtin);
620 else bc_parse_expr_status(p, flags, bc_parse_next_rel);
656 * @param flags The expression parsing flags for parsing a scale() arg.
659 bc_parse_scale(BcParse* p, BcInst* type, bool* can_assign, uint8_t flags)
677 // Once again, adjust the flags.
678 flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
679 flags |= BC_PARSE_NEEDVAL;
683 bc_parse_expr_status(p, flags, bc_parse_next_rel);
701 * @param flags The expression parsing flags for parsing a scale() arg.
705 uint8_t flags)
750 uint8_t flags2 = flags & ~(BC_PARSE_ARRAY);
933 * Clears flags that indicate the end of an if statement and its block and sets
956 if (BC_ERR(p->flags.len <= 1)) bc_parse_err(p, BC_ERR_PARSE_TOKEN);
978 size_t len = p->flags.len;
1002 bc_vec_pop(&p->flags);
1010 bc_vec_pop(&p->flags);
1013 // of the flags stack because they have been taken care of above.
1014 else if (has_brace && !BC_PARSE_IF(p)) bc_vec_pop(&p->flags);
1017 if (BC_PARSE_IF(p) && (len == p->flags.len || !BC_PARSE_BRACE(p)))
1025 // *Now* we can pop the flags.
1026 bc_vec_pop(&p->flags);
1050 // the flags stack does not have enough, we should stop. If we have a
1054 while (p->flags.len > 1 && !new_else && (!BC_PARSE_IF_END(p) || brace) &&
1058 if (BC_ERR(p->flags.len == 1 && brace)) bc_parse_err(p, BC_ERR_PARSE_TOKEN);
1062 uint16_t flags = BC_PARSE_TOP_FLAG(p);
1065 // popping its flags.
1066 if (!(flags & (BC_PARSE_FLAG_FUNC_INNER | BC_PARSE_FLAG_LOOP_INNER)) &&
1067 !(flags & (BC_PARSE_FLAG_IF | BC_PARSE_FLAG_ELSE)) &&
1068 !(flags & (BC_PARSE_FLAG_IF_END)))
1070 bc_vec_pop(&p->flags);
1078 * @param flags The current flags (will be edited).
1081 bc_parse_startBody(BcParse* p, uint16_t flags)
1083 assert(flags);
1084 flags |= (BC_PARSE_TOP_FLAG(p) & (BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_LOOP));
1085 flags |= BC_PARSE_FLAG_BODY;
1086 bc_vec_push(&p->flags, &flags);
1102 for (i = 0; good && i < p->flags.len; ++i)
1104 uint16_t flag = *((uint16_t*) bc_vec_item(&p->flags, i));
1118 while (p->flags.len > 1 || BC_PARSE_IF_END(p))
1121 if (p->flags.len > 1) bc_parse_endBody(p, false);
1139 uint8_t flags = (BC_PARSE_REL | BC_PARSE_NEEDVAL);
1147 bc_parse_expr_status(p, flags, bc_parse_next_rel);
1204 uint8_t flags = (BC_PARSE_REL | BC_PARSE_NEEDVAL);
1217 bc_parse_expr_status(p, flags, bc_parse_next_rel);
1265 uint8_t flags = (BC_PARSE_REL | BC_PARSE_NEEDVAL);
1266 bc_parse_expr_status(p, flags, bc_parse_next_for);
1373 uint16_t flags;
1481 flags = BC_PARSE_FLAG_FUNC | BC_PARSE_FLAG_FUNC_INNER;
1482 bc_parse_startBody(p, flags);
1565 assert(p->flags.len >= 2);
1595 size_t len = p->flags.len;
1603 // brace, and no body flag, and the flags len hasn't shrunk, then we
1606 if (!brace && !BC_PARSE_BODY(p) && len <= p->flags.len)
1622 uint16_t flags;
1652 if (p->flags.len > 1 && !BC_PARSE_BRACE(p))
1692 len = p->flags.len;
1693 flags = BC_PARSE_TOP_FLAG(p);
1922 // If the flags did not change, we expect a delimiter.
1923 if (len == p->flags.len && flags == BC_PARSE_TOP_FLAG(p))
1990 * @param flags The flags for what is valid in the expression.
1998 bc_parse_expr_err(BcParse* p, uint8_t flags, BcParseNext next)
2009 assert(!(flags & BC_PARSE_PRINT) || !(flags & BC_PARSE_NEEDVAL));
2040 if (!(flags & BC_PARSE_NOREAD))
2068 bc_parse_incdec(p, &prev, &can_assign, &nexprs, flags);
2072 flags &= ~(BC_PARSE_ARRAY);
2093 flags &= ~(BC_PARSE_ARRAY);
2109 flags &= ~(BC_PARSE_ARRAY);
2186 flags &= ~(BC_PARSE_ARRAY);
2281 bc_parse_name(p, &prev, &can_assign, flags & ~BC_PARSE_NOCALL);
2286 flags &= ~(BC_PARSE_ARRAY);
2306 flags &= ~(BC_PARSE_ARRAY);
2330 flags &= ~(BC_PARSE_ARRAY);
2351 bc_parse_builtin(p, t, flags, &prev);
2355 flags &= ~(BC_PARSE_ARRAY);
2381 else if (t == BC_LEX_KW_READ && BC_ERR(flags & BC_PARSE_NOREAD))
2391 flags &= ~(BC_PARSE_ARRAY);
2406 bc_parse_scale(p, &prev, &can_assign, flags);
2410 flags &= ~(BC_PARSE_ARRAY);
2424 bc_parse_builtin3(p, t, flags, &prev);
2428 flags &= ~(BC_PARSE_ARRAY);
2533 if (!(flags & BC_PARSE_REL) && nrelops)
2537 else if ((flags & BC_PARSE_REL) && nrelops > 1)
2545 if (!(flags & BC_PARSE_NEEDVAL) && !pfirst)
2557 else if (incdec && !(flags & BC_PARSE_PRINT))
2582 if ((flags & BC_PARSE_PRINT))
2590 else if (!(flags & BC_PARSE_NEEDVAL) &&
2621 * @param flags The flags for what is valid in the expression.
2625 bc_parse_expr_status(BcParse* p, uint8_t flags, BcParseNext next)
2627 BcParseStatus s = bc_parse_expr_err(p, flags, next);
2636 bc_parse_expr(BcParse* p, uint8_t flags)
2639 bc_parse_expr_status(p, flags, bc_parse_next_read);