Lines Matching refs:stack
646 stack: minimumStackMessage
651 stack: e.stack || minimumStackMessage
656 stack: minimumStackMessage
6704 this.stack = new Error().stack;
34119 var stack = this.tmpBuf,
34130 stack[sp++] = b & 0x7F;
34138 while (bufferSize < 8 && stack.length > 0) {
34139 buffer = stack[--sp] << bufferSize | buffer;
36545 var stack = [];
36563 stack.push(data[i++]);
36574 stack.push(b << 8 | data[i++]);
36584 stack.push(data[i++]);
36595 stack.push(b << 8 | data[i++]);
36600 funcId = stack[stack.length - 1];
36608 var newStackLength = stack.length + ttContext.functionsStackDeltas[funcId];
36616 stack.length = newStackLength;
36621 stackTop: stack.length - 1
36645 funcId = stack.pop();
36666 ttContext.functionsStackDeltas[funcId] = stack.length - pc.stackTop;
36688 var offset = stack[stack.length - 1];
36700 n = stack.pop();
36707 while (stackDelta < 0 && stack.length > 0) {
36708 stack.pop();
36713 stack.push(NaN);
38009 stackFn: function stack_div(stack, index) {
38010 stack[index - 2] = stack[index - 2] + stack[index - 1];
38016 stackFn: function stack_div(stack, index) {
38017 stack[index - 2] = stack[index - 2] - stack[index - 1];
38023 stackFn: function stack_div(stack, index) {
38024 stack[index - 2] = stack[index - 2] / stack[index - 1];
38030 stackFn: function stack_div(stack, index) {
38031 stack[index - 1] = -stack[index - 1];
38061 stackFn: function stack_div(stack, index) {
38062 stack[index - 2] = stack[index - 2] * stack[index - 1];
38362 var stack = state.stack;
38380 stack[stackSize] = (data[j] << 24 | data[j + 1] << 16) >> 16;
38388 state.seac = stack.slice(stackSize, stackSize + 4);
38395 stack[stackSize] = value - 139;
38398 …stack[stackSize] = value < 251 ? (value - 247 << 8) + data[j] + 108 : -(value - 251 << 8) - data[j…
38402 … stack[stackSize] = (data[j] << 24 | data[j + 1] << 16 | data[j + 2] << 8 | data[j + 3]) / 65536;
38433 var subrNumber = stack[--stackSize] + bias;
38488 if (stackSize > 0 && stack[stackSize - 1] >= 0) {
38489 state.width = stack[stackSize - 1];
38495 validationCommand.stackFn(stack, stackSize);
38531 stack: [],
47373 var stack = [];
47409 stems += stack.length >> 1;
47414 stems += stack.length >> 1;
47419 y += stack.pop();
47425 while (stack.length > 0) {
47426 x += stack.shift();
47427 y += stack.shift();
47434 while (stack.length > 0) {
47435 x += stack.shift();
47438 if (stack.length === 0) {
47442 y += stack.shift();
47449 while (stack.length > 0) {
47450 y += stack.shift();
47453 if (stack.length === 0) {
47457 x += stack.shift();
47464 while (stack.length > 0) {
47465 xa = x + stack.shift();
47466 ya = y + stack.shift();
47467 xb = xa + stack.shift();
47468 yb = ya + stack.shift();
47469 x = xb + stack.shift();
47470 y = yb + stack.shift();
47477 n = stack.pop();
47517 xa = x + stack.shift();
47518 xb = xa + stack.shift();
47519 y1 = y + stack.shift();
47520 x = xb + stack.shift();
47522 xa = x + stack.shift();
47523 xb = xa + stack.shift();
47524 x = xb + stack.shift();
47529 xa = x + stack.shift();
47530 ya = y + stack.shift();
47531 xb = xa + stack.shift();
47532 yb = ya + stack.shift();
47533 x = xb + stack.shift();
47534 y = yb + stack.shift();
47536 xa = x + stack.shift();
47537 ya = y + stack.shift();
47538 xb = xa + stack.shift();
47539 yb = ya + stack.shift();
47540 x = xb + stack.shift();
47541 y = yb + stack.shift();
47543 stack.pop();
47547 xa = x + stack.shift();
47548 y1 = y + stack.shift();
47549 xb = xa + stack.shift();
47550 y2 = y1 + stack.shift();
47551 x = xb + stack.shift();
47553 xa = x + stack.shift();
47554 xb = xa + stack.shift();
47555 y3 = y2 + stack.shift();
47556 x = xb + stack.shift();
47563 xa = x + stack.shift();
47564 ya = y + stack.shift();
47565 xb = xa + stack.shift();
47566 yb = ya + stack.shift();
47567 x = xb + stack.shift();
47568 y = yb + stack.shift();
47570 xa = x + stack.shift();
47571 ya = y + stack.shift();
47572 xb = xa + stack.shift();
47573 yb = ya + stack.shift();
47578 x += stack.shift();
47580 y += stack.shift();
47593 if (stack.length >= 4) {
47594 var achar = stack.pop();
47595 var bchar = stack.pop();
47596 y = stack.pop();
47597 x = stack.pop();
47617 stems += stack.length >> 1;
47622 stems += stack.length >> 1;
47628 stems += stack.length >> 1;
47634 y += stack.pop();
47635 x += stack.pop();
47641 x += stack.pop();
47647 stems += stack.length >> 1;
47652 while (stack.length > 2) {
47653 xa = x + stack.shift();
47654 ya = y + stack.shift();
47655 xb = xa + stack.shift();
47656 yb = ya + stack.shift();
47657 x = xb + stack.shift();
47658 y = yb + stack.shift();
47662 x += stack.shift();
47663 y += stack.shift();
47668 while (stack.length > 6) {
47669 x += stack.shift();
47670 y += stack.shift();
47674 xa = x + stack.shift();
47675 ya = y + stack.shift();
47676 xb = xa + stack.shift();
47677 yb = ya + stack.shift();
47678 x = xb + stack.shift();
47679 y = yb + stack.shift();
47684 if (stack.length % 2) {
47685 x += stack.shift();
47688 while (stack.length > 0) {
47690 ya = y + stack.shift();
47691 xb = xa + stack.shift();
47692 yb = ya + stack.shift();
47694 y = yb + stack.shift();
47701 if (stack.length % 2) {
47702 y += stack.shift();
47705 while (stack.length > 0) {
47706 xa = x + stack.shift();
47708 xb = xa + stack.shift();
47709 yb = ya + stack.shift();
47710 x = xb + stack.shift();
47718 stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
47723 n = stack.pop() + font.gsubrsBias;
47733 while (stack.length > 0) {
47735 ya = y + stack.shift();
47736 xb = xa + stack.shift();
47737 yb = ya + stack.shift();
47738 x = xb + stack.shift();
47739 y = yb + (stack.length === 1 ? stack.shift() : 0);
47742 if (stack.length === 0) {
47746 xa = x + stack.shift();
47748 xb = xa + stack.shift();
47749 yb = ya + stack.shift();
47750 y = yb + stack.shift();
47751 x = xb + (stack.length === 1 ? stack.shift() : 0);
47758 while (stack.length > 0) {
47759 xa = x + stack.shift();
47761 xb = xa + stack.shift();
47762 yb = ya + stack.shift();
47763 y = yb + stack.shift();
47764 x = xb + (stack.length === 1 ? stack.shift() : 0);
47767 if (stack.length === 0) {
47772 ya = y + stack.shift();
47773 xb = xa + stack.shift();
47774 yb = ya + stack.shift();
47775 x = xb + stack.shift();
47776 y = yb + (stack.length === 1 ? stack.shift() : 0);
47788 stack.push(v - 139);
47790 stack.push((v - 247) * 256 + code[i++] + 108);
47792 stack.push(-(v - 251) * 256 - code[i++] - 108);
47794 … stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
47802 stack.length = 0;
48049 this.stack = [];
48069 this.stack = [];
48078 this.stack = [];
48087 if (this.stack.length < 1) {
48092 var dy = this.stack.pop();
48093 this.stack.push(0, dy);
48117 this.stack = [];
48121 if (this.stack.length < 1) {
48126 subrNumber = this.stack.pop();
48140 if (this.stack.length < 2) {
48145 wx = this.stack.pop();
48146 sbx = this.stack.pop();
48149 this.stack.push(wx, sbx);
48167 this.stack.push(0);
48183 this.stack = [];
48188 this.stack = [];
48197 this.stack = [];
48206 this.seac = this.stack.splice(-4, 4);
48215 if (this.stack.length < 4) {
48220 this.stack.pop();
48221 wx = this.stack.pop();
48222 var sby = this.stack.pop();
48223 sbx = this.stack.pop();
48226 this.stack.push(wx, sbx, sby);
48231 if (this.stack.length < 2) {
48236 var num2 = this.stack.pop();
48237 var num1 = this.stack.pop();
48238 this.stack.push(num1 / num2);
48242 if (this.stack.length < 2) {
48247 subrNumber = this.stack.pop();
48248 var numArgs = this.stack.pop();
48251 var flexArgs = this.stack.splice(this.stack.length - 17, 17);
48252 …this.stack.push(flexArgs[2] + flexArgs[0], flexArgs[3] + flexArgs[1], flexArgs[4], flexArgs[5], fl…
48255 this.stack.push(flexArgs[15], flexArgs[16]);
48266 this.stack = [];
48289 this.stack.push(value);
48295 var stackLength = this.stack.length;
48304 var value = this.stack[i];
48317 this.stack.splice(start, howManyArgs);
48319 this.stack.length = 0;
53421 var stack = evaluator.execute(input);
53422 var stackIndex = stack.length - numOutputs;
53425 value = stack[stackIndex + i];
53472 this.stack = !initialStack ? [] : Array.prototype.slice.call(initialStack, 0);
53477 if (this.stack.length >= MAX_STACK_SIZE) {
53481 this.stack.push(value);
53484 if (this.stack.length <= 0) {
53488 return this.stack.pop();
53491 if (this.stack.length + n >= MAX_STACK_SIZE) {
53495 var stack = this.stack;
53497 for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
53498 stack.push(stack[i]);
53502 this.push(this.stack[this.stack.length - n - 1]);
53505 var stack = this.stack;
53506 var l = stack.length - n;
53507 var r = stack.length - 1,
53514 t = stack[i];
53515 stack[i] = stack[j];
53516 stack[j] = t;
53520 t = stack[i];
53521 stack[i] = stack[j];
53522 stack[j] = t;
53526 t = stack[i];
53527 stack[i] = stack[j];
53528 stack[j] = t;
53542 var stack = new PostScriptStack(initialStack);
53552 stack.push(operator);
53558 b = stack.pop();
53559 a = stack.pop();
53568 a = stack.pop();
53573 a = stack.pop();
53574 stack.push(Math.abs(a));
53578 b = stack.pop();
53579 a = stack.pop();
53580 stack.push(a + b);
53584 b = stack.pop();
53585 a = stack.pop();
53588 stack.push(a && b);
53590 stack.push(a & b);
53596 a = stack.pop();
53597 stack.push(Math.atan(a));
53601 b = stack.pop();
53602 a = stack.pop();
53605 stack.push(a << b);
53607 stack.push(a >> b);
53613 a = stack.pop();
53614 stack.push(Math.ceil(a));
53618 a = stack.pop();
53619 stack.copy(a);
53623 a = stack.pop();
53624 stack.push(Math.cos(a));
53628 a = stack.pop() | 0;
53629 stack.push(a);
53636 b = stack.pop();
53637 a = stack.pop();
53638 stack.push(a / b);
53642 stack.copy(1);
53646 b = stack.pop();
53647 a = stack.pop();
53648 stack.push(a === b);
53652 stack.roll(2, 1);
53656 b = stack.pop();
53657 a = stack.pop();
53658 stack.push(Math.pow(a, b));
53662 stack.push(false);
53666 a = stack.pop();
53667 stack.push(Math.floor(a));
53671 b = stack.pop();
53672 a = stack.pop();
53673 stack.push(a >= b);
53677 b = stack.pop();
53678 a = stack.pop();
53679 stack.push(a > b);
53683 b = stack.pop();
53684 a = stack.pop();
53685 stack.push(a / b | 0);
53689 a = stack.pop();
53690 stack.index(a);
53694 b = stack.pop();
53695 a = stack.pop();
53696 stack.push(a <= b);
53700 a = stack.pop();
53701 stack.push(Math.log(a));
53705 a = stack.pop();
53706 stack.push(Math.log(a) / Math.LN10);
53710 b = stack.pop();
53711 a = stack.pop();
53712 stack.push(a < b);
53716 b = stack.pop();
53717 a = stack.pop();
53718 stack.push(a % b);
53722 b = stack.pop();
53723 a = stack.pop();
53724 stack.push(a * b);
53728 b = stack.pop();
53729 a = stack.pop();
53730 stack.push(a !== b);
53734 a = stack.pop();
53735 stack.push(-a);
53739 a = stack.pop();
53742 stack.push(!a);
53744 stack.push(~a);
53750 b = stack.pop();
53751 a = stack.pop();
53754 stack.push(a || b);
53756 stack.push(a | b);
53762 stack.pop();
53766 b = stack.pop();
53767 a = stack.pop();
53768 stack.roll(a, b);
53772 a = stack.pop();
53773 stack.push(Math.round(a));
53777 a = stack.pop();
53778 stack.push(Math.sin(a));
53782 a = stack.pop();
53783 stack.push(Math.sqrt(a));
53787 b = stack.pop();
53788 a = stack.pop();
53789 stack.push(a - b);
53793 stack.push(true);
53797 a = stack.pop();
53799 stack.push(a);
53803 b = stack.pop();
53804 a = stack.pop();
53807 stack.push(a !== b);
53809 stack.push(a ^ b);
53819 return stack.stack;
54023 var stack = [];
54033 stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));
54040 stack.push(new AstLiteral(item));
54046 if (stack.length < 2) {
54050 num2 = stack.pop();
54051 num1 = stack.pop();
54052 stack.push(buildAddOperation(num1, num2));
54056 if (stack.length < 1) {
54063 if (stack.length < 2) {
54067 num2 = stack.pop();
54068 num1 = stack.pop();
54069 stack.push(buildMulOperation(num1, num2));
54073 if (stack.length < 2) {
54077 num2 = stack.pop();
54078 num1 = stack.pop();
54079 stack.push(buildSubOperation(num1, num2));
54083 if (stack.length < 2) {
54087 ast1 = stack.pop();
54088 ast2 = stack.pop();
54089 stack.push(ast1, ast2);
54093 if (stack.length < 1) {
54097 stack.pop();
54101 if (stack.length < 1) {
54105 num1 = stack.pop();
54113 if (n < 0 || !Number.isInteger(n) || stack.length < n) {
54117 ast1 = stack[stack.length - n - 1];
54120 stack.push(ast1);
54125 stack[stack.length - n - 1] = tmpVar;
54126 stack.push(tmpVar);
54131 if (stack.length < 1) {
54136 num1 = stack.pop();
54137 stack.push(buildMinOperation(num1, code[i + 1]));
54142 ast1 = stack[stack.length - 1];
54145 stack.push(ast1);
54150 stack[stack.length - 1] = tmpVar;
54151 stack.push(tmpVar);
54156 if (stack.length < 2) {
54160 num2 = stack.pop();
54161 num1 = stack.pop();
54170 if (n <= 0 || !Number.isInteger(n) || !Number.isInteger(j) || stack.length < n) {
54180 Array.prototype.push.apply(stack, stack.splice(stack.length - n, n - j));
54188 if (stack.length !== outputSize) {
54198 stack.forEach(function (expr, i) {