Lines Matching defs:len
135 size_t len, cap, size;
146 unsigned long rdx, len, cap;
158 #define BC_NUM_ONE(n) ((n)->len == 1 && (n)->rdx == 0 && (n)->num[0] == 1)
159 #define BC_NUM_INT(n) ((n)->len - (n)->rdx)
160 #define BC_NUM_CMP_ZERO(a) (BC_NUM_NEG((a)->len != 0, (a)->neg))
310 size_t len;
318 void bc_array_expand(BcVec *a, size_t len);
411 size_t len;
433 char len, tokens[4];
437 #define BC_PARSE_NEXT(a, ...) { .len = a, BC_PARSE_NEXT_TOKENS(__VA_ARGS__) }
506 #define BC_PARSE_NO_EXEC(p) ((p)->flags.len != 1 || BC_PARSE_TOP_FLAG(p) != 0)
571 #define BC_PROG_STACK(s, n) ((s)->len >= ((size_t) (n)))
869 while (v->cap < v->len + n) v->cap *= 2;
876 v->len = 0;
889 if (!v->dtor) v->len -= n;
891 size_t len = v->len - n;
892 while (v->len > len) v->dtor(v->v + (v->size * --v->len));
898 memcpy(v->v + (v->size * v->len), data, v->size * n);
899 v->len += n;
926 if (idx == v->len) bc_vec_push(v, data);
935 memmove(ptr + v->size, ptr, v->size * (v->len++ - idx));
940 void bc_vec_string(BcVec *v, size_t len, char *str) {
942 bc_vec_npop(v, v->len);
943 bc_vec_expand(v, len + 1);
944 memcpy(v->v, str, len);
945 v->len = len;
951 unsigned long len;
953 if (!v->len) bc_vec_pushByte(v, '\0');
955 len = strlen(str);
956 bc_vec_grow(v, len);
957 strcpy(v->v+v->len-1, str);
958 v->len += len;
962 bc_vec_npop(v, v->len);
971 return v->v + v->size * (v->len - idx - 1);
976 bc_vec_npop(v, v->len);
982 size_t low = 0, high = v->len;
1002 if (*i == v->len) bc_vec_push(v, ptr);
1011 if (i >= v->len) return SIZE_MAX;
1030 bc_vec_npop(vec, vec->len);
1082 if (bc_read_binary(vec->v, vec->len - 1))
1135 n->len = 0;
1142 n->len = 1;
1148 n->len = 2;
1154 size_t len;
1155 for (len = 1; i; i /= 10, ++len);
1156 return len;
1159 static BcStatus bc_num_subArrays(signed char *a, signed char *b, size_t len)
1162 for (i = 0; !TT.sig && i < len; ++i) {
1171 static ssize_t bc_num_compare(signed char *a, signed char *b, size_t len)
1176 for (i = len - 1; !TT.sig && i < len && !(c = a[i] - b[i]); --i);
1188 if (!a->len) return BC_NUM_NEG(b->len != 0, !b->neg);
1189 if (!b->len) return BC_NUM_CMP_ZERO(a);
1225 while (n->len && !n->num[n->len - 1]) --n->len;
1226 if (!n->len) n->neg = 0;
1227 else if (n->len < n->rdx) n->len = n->rdx;
1236 if (n->len) {
1237 n->len -= places;
1238 memmove(n->num, n->num + places, n->len);
1245 size_t len = n->len + places;
1249 if (n->cap < len) bc_num_expand(n, len);
1251 memmove(n->num + places, n->num, n->len);
1254 if (n->len) n->len += places;
1265 if (n->len) n->neg = (!neg1 != !neg2);
1270 if (idx < n->len) {
1272 b->len = n->len - idx;
1273 a->len = idx;
1276 memcpy(b->num, n->num + idx, b->len);
1288 if (!places || !n->len) return BC_STATUS_SUCCESS;
1289 if (places + n->len > BC_MAX_NUM)
1331 if (!a->len) {
1333 if (sub && c->len) c->neg = !c->neg;
1336 if (!b->len) {
1360 c->len = diff;
1384 c->len += i;
1386 if (carry) c->num[c->len++] = carry;
1402 if (!a->len) {
1404 if (sub && c->len) c->neg = !c->neg;
1407 if (!b->len) {
1447 s = bc_num_subArrays(c->num + start, subtrahend->num, subtrahend->len);
1457 size_t max = maxof(a->len, b->len), max2 = (max + 1) / 2;
1463 if (!a->len || !b->len) {
1473 if (a->len + b->len < 32 || a->len < 32 || b->len < 32)
1475 size_t i, j, len;
1479 bc_num_expand(c, a->len + b->len + 1);
1483 c->len = len = 0;
1485 for (i = 0; !TT.sig && i < b->len; ++i) {
1491 for (j = 0; !TT.sig && j < a->len; ++j) {
1498 len = maxof(len, i + j + (carry != 0));
1501 c->len = len;
1583 bc_num_expand(c, c->len + maxrdx);
1585 if (c->len < maxrdx) {
1586 memset(c->num + c->len, 0, c->cap - c->len);
1587 c->len += maxrdx;
1603 size_t len, end, i;
1607 if (!b->len) return bc_vm_err(BC_ERROR_MATH_DIVIDE_BY_ZERO);
1608 if (!a->len) {
1620 len = b->len;
1622 if (len > cp.len) {
1623 bc_num_expand(&cp, len + 2);
1624 bc_num_extend(&cp, len - cp.len);
1631 if (b->rdx == b->len) {
1632 for (i = 0; zero && i < len; ++i) zero = !b->num[len - i - 1];
1633 len -= i - 1;
1636 if (cp.cap == cp.len) bc_num_expand(&cp, cp.len + 1);
1639 cp.num[cp.len++] = 0;
1640 end = cp.len - len;
1642 bc_num_expand(c, cp.len);
1646 c->len = cp.len;
1651 for (q = 0; !s && (n[len] || bc_num_compare(n, p, len) >= 0); ++q)
1652 s = bc_num_subArrays(n, p, len);
1669 if (!b->len) return bc_vm_err(BC_ERROR_MATH_DIVIDE_BY_ZERO);
1670 if (!a->len) {
1686 if (ts > d->rdx && d->len) bc_num_extend(d, ts - d->rdx);
1701 size_t ts = maxof(scale + b->rdx, a->rdx), len = bc_num_mulReq(a, b, ts);
1703 bc_num_init(&c1, len);
1720 if (!b->len) {
1724 if (!a->len) {
1785 for (zero = 1, i = 0; zero && i < c->len; ++i) zero = !c->num[i];
1844 size_t i, digits, len = strlen(val);
1846 for (i = 0; zero && i < len; ++i) zero = (val[i] == '.' || val[i] == '0');
1852 for (i = 0; i < len && (c = val[i]) && c != '.'; ++i) {
1863 if (i == len && !(c = val[i])) goto int_err;
1865 bc_num_init(&result, base->len);
1868 for (i += 1, digits = 0; i < len && (c = val[i]); ++i, ++digits) {
1886 if (n->len) {
1908 static void bc_num_printDigits(size_t n, size_t len, int rdx) {
1917 for (exp = 0, pow = 1; exp < len - 1; ++exp, pow *= 10);
1919 for (exp = 0; exp < len; pow /= 10, ++TT.nchars, ++exp) {
1928 static void bc_num_printHex(size_t n, size_t len, int rdx) {
1938 TT.nchars += len;
1948 for (i = n->len - 1; i < n->len; --i)
1953 size_t len, BcNumDigitOp print)
1962 if (!n->len) {
1963 print(0, len, 0);
1969 bc_num_init(&digit, len);
1978 while (intp.len) {
1986 for (i = 0; i < stack.len; ++i) {
1988 print(*ptr, len, 0);
1993 for (radix = 1; frac_len.len <= n->rdx; radix = 0) {
2001 print(dig, len, radix);
2044 n->rdx = n->len = 0;
2067 bc_num_expand(d, s->len);
2068 d->len = s->len;
2071 memcpy(d->num, s->num, d->len);
2075 bc_num_init(d, s->len);
2091 size_t len, i;
2097 len = strlen(val);
2098 if (len) {
2099 for (i = 0; zero && i < len; ++i) zero = (val[i] == '0') || val[i] == '.';
2100 bc_num_expand(n, len);
2103 n->rdx = ptr ? (val + len) - (ptr + 1) : 0;
2106 for (i = len - 1; i < len; ++n->len, --i) {
2110 if (c == '.') n->len -= 1;
2113 n->num[n->len] = c - '0';
2131 for (r = 0, i = n->len; i > n->rdx;) {
2150 size_t len;
2158 len = bc_num_log10(ULONG_MAX);
2159 bc_num_expand(n, len);
2160 for (ptr = n->num, i = 0; val; ++i, ++n->len, val /= 10) ptr[i] = val % 10;
2172 return a->len + b->len + 1;
2198 return bc_num_binary(a, b, c, scale, bc_num_p, a->len + b->len + 1);
2205 size_t pow, len, digs, digs1, resrdx, times = 0;
2211 if (!a->len) {
2223 len = a->len + scale;
2225 bc_num_init(&num1, len);
2226 bc_num_init(&num2, len);
2233 bc_num_init(&f, len);
2234 bc_num_init(&fprime, len);
2257 len = BC_NUM_INT(x0) + resrdx - 1;
2259 while (!TT.sig && (cmp || digs < len)) {
2269 digs = x1->len - (unsigned long long) llabs(cmp);
2307 size_t ts = maxof(scale + b->rdx, a->rdx), len = bc_num_mulReq(a, b, ts);
2312 bc_num_init(c, len);
2317 bc_num_expand(c, len);
2344 for (i = 0; i < f->autos.len; ++i) {
2346 if (!strcmp(name, id->str) && type == (BcType) id->len)
2350 a.len = type;
2370 bc_vec_npop(&f->code, f->code.len);
2371 bc_vec_npop(&f->strs, f->strs.len);
2372 bc_vec_npop(&f->consts, f->consts.len);
2373 bc_vec_npop(&f->autos, f->autos.len);
2374 bc_vec_npop(&f->labels, f->labels.len);
2398 bc_vec_npop(d, d->len);
2400 d->len = s->len;
2402 for (i = 0; i < s->len; ++i) {
2408 void bc_array_expand(BcVec *a, size_t len) {
2412 while (len > a->len) {
2419 while (len > a->len) {
2468 while (l->i < l->len && l->buf[l->i] != '\n') ++l->i;
2514 bc_vec_npop(&l->str, l->str.len);
2543 if (l->str.len - pt > BC_MAX_NUM)
2593 if (l->i == l->len) return BC_STATUS_SUCCESS;
2607 l->len = strlen(text);
2621 size_t len = BC_LEX_KW_LEN(kw);
2623 if (!strncmp(buf, kw->name, len) && !isalnum(buf[len]) && buf[len] != '_')
2633 l->i += len - 1;
2641 if (l->str.len - 1 > 1) s = bc_lex_vposixErr(l, BC_ERROR_POSIX_NAME_LEN, buf);
2648 size_t len, nlines = 0, i = l->i;
2661 len = i - l->i;
2663 if (len > BC_MAX_STRING)
2666 bc_vec_string(&l->str, len, l->buf + l->i);
2991 size_t idx = v->len;
3013 p->l.i = p->l.len;
3017 bc_vec_npop(&p->flags, p->flags.len - 1);
3018 bc_vec_npop(&p->exits, p->exits.len);
3019 bc_vec_npop(&p->conds, p->conds.len);
3020 bc_vec_npop(&p->ops, p->ops.len);
3070 for (i = 0; i < p->flags.len && BC_PARSE_BLOCK_STMT(flags); ++i) {
3083 for (i = 0; !good && i < p->flags.len; ++i) {
3099 *label = func->code.len;
3109 bc_parse_createLabel(p, p->func->code.len);
3119 ip.len = 0;
3142 while (p->ops.len > start) {
3162 if (p->ops.len <= ops_bgn) return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
3171 if (p->ops.len <= ops_bgn) return bc_parse_err(p, BC_ERROR_PARSE_EXPR);
3232 ((struct str_len *)bc_vec_item(&p->prog->fn_map, idx))->len);
3539 if (p->flags.len <= 1) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
3554 size_t len = p->flags.len;
3585 if (BC_PARSE_IF(p) && (len == p->flags.len || !BC_PARSE_BRACE(p))) {
3603 } while (p->flags.len > 1 && !new_else && (!BC_PARSE_IF_END(p) || brace) &&
3606 if (!s && p->flags.len == 1 && brace)
3652 idx = p->func->labels.len;
3663 size_t idx = p->func->labels.len;
3689 bc_parse_createCondLabel(p, p->func->labels.len);
3691 idx = p->func->labels.len;
3730 cond_idx = p->func->labels.len;
3735 bc_parse_createLabel(p, p->func->code.len);
3774 bc_parse_createLabel(p, p->func->code.len);
3792 if (!p->exits.len) return bc_parse_err(p, BC_ERROR_PARSE_TOKEN);
3794 i = p->exits.len - 1;
3797 while (!ip->func && i < p->exits.len) ip = bc_vec_item(&p->exits, i--);
3798 if (i >= p->exits.len && !ip->func)
3986 size_t len = p->flags.len;
3988 if (!s && !brace && !BC_PARSE_BODY(p) && len <= p->flags.len)
3998 size_t len;
4011 if (p->flags.len > 1 && !BC_PARSE_BRACE(p))
4033 len = p->flags.len;
4157 if (!s && len == p->flags.len && flags == BC_PARSE_TOP_FLAG(p)) {
4187 size_t nexprs = 0, ops_bgn = p->ops.len;
4407 while (p->ops.len > ops_bgn) {
4423 for (i = 0; i < next.len && t != next.tokens[i]; ++i);
4424 if (i == next.len && !bc_parse_isDelimiter(p))
4443 for (incdec = 1, i = 0; i < next.len && incdec; ++i)
4528 e.len = v->len;
4539 return bc_vec_item(v, ptr->len);
4551 char *str = bc_program_str(p, r->d.id.len, 0);
4552 size_t len = strlen(str);
4554 bc_num_init(n, len);
4556 s = bc_num_parse(n, str, &p->ib, p->ib_t, len == 1);
4587 size_t idx = r->d.id.len;
4591 if (v->len <= idx) bc_array_expand(v, idx + 1);
4744 for (i = 0; i < p->stack.len; ++i) {
4752 bc_vec_npop(&f->code, f->code.len);
4775 ip.len = p->results.len;
4838 if (!n->len) bc_num_printHex(0, 1, 0);
4849 size_t i = (r->t == BC_RESULT_STR) ? r->d.id.len : n->rdx;
4871 if (rn->len) rn->neg = !rn->neg;
4887 bc_num_init(&res.d.n, num->len);
5099 r.d.id.len = temp;
5153 if (!f->code.len) return bc_vm_verr(BC_ERROR_EXEC_UNDEF_FUNC, f->name);
5156 ip.len = p->results.len - nparams;
5172 (!id->len) != (arg->t == BC_RESULT_VAR);
5176 s = bc_program_copyToVar(p, a->str, a->len, last);
5180 for (; i < f->autos.len; ++i) {
5183 v = bc_program_search(p, a->str, a->len);
5185 if (a->len == BC_TYPE_VAR) {
5225 for (i = 0; i < f->autos.len; ++i) {
5230 v = bc_program_search(p, a->str, a->len);
5234 bc_vec_npop(&p->results, p->results.len - ip->len);
5247 unsigned long len = n->len;
5250 if (n->rdx != n->len) return len;
5251 for (i = n->len - 1; i < n->len && !n->num[i]; --len, --i);
5253 return len;
5262 int len = (inst == BC_INST_LENGTH);
5276 if (len) {
5278 val = (unsigned long) ((BcVec*) num)->len;
5365 id.len = p->fns.len;
5368 idx = ((struct ptr_len *)bc_vec_item(&p->fn_map, idx))->len;
5384 bc_vec_npop(&p->stack, p->stack.len - 1);
5385 bc_vec_npop(&p->results, p->results.len);
5389 ip->idx = f->code.len;
5418 while (!s && ip->idx < func->code.len) {
5529 r.d.id.len = bc_program_index(code, &ip->idx);
5551 r.d.id.len = bc_program_index(code, &ip->idx);
5603 size_t len = strlen(bc_sig_msg);
5604 if (write(2, bc_sig_msg, len) != len) sig = 0;
5672 if (!BC_PARSE_NO_EXEC(&BC_VM->prs) && prog->stack.len == 1 &&
5673 !prog->results.len && ip->idx == f->code.len)
5675 bc_vec_npop(&f->labels, f->labels.len);
5676 bc_vec_npop(&f->strs, f->strs.len);
5677 bc_vec_npop(&f->consts, f->consts.len);
5678 bc_vec_npop(&f->code, f->code.len);
5698 if (!is_stdin && BC_VM->prs.flags.len == 1 && *flags == BC_PARSE_FLAG_IF_END)
5750 buf.len > 1 && !TT.sig && s != BC_STATUS_SIGNAL)
5753 size_t i, len = buf.len - 1;
5757 if (len >= 2 && str[len - 1] == '\n' && str[len - 2] == '\\') {
5762 for (i = 0; i < len; ++i) {
5764 int notend = len > i + 1;
5767 if (!comment && (i - 1 > len || str[i - 1] != '\\')) string ^= c == '"';
5787 if (len >= 2 && str[len - 2] == '\\' && str[len - 1] == '\n') continue;
5827 int len = atoi(ss);
5828 if (len>=2 && len <= UINT16_MAX) TT.line_len = len;