mirror of
https://github.com/mozilla/pdf.js.git
synced 2025-04-25 17:48:07 +02:00
Moves shared/function.js to core/
This commit is contained in:
Yury Delendik
parent
7a19085159
commit
fcc4dfd9b5
10 changed files with 19 additions and 23 deletions
|
|
@ -1,723 +0,0 @@
|
|||
/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||||
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
|
||||
/* Copyright 2012 Mozilla Foundation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
/* globals PostScriptLexer, PostScriptParser, error, info, isArray, isBool */
|
||||
|
||||
'use strict';
|
||||
|
||||
var PDFFunction = (function PDFFunctionClosure() {
|
||||
var CONSTRUCT_SAMPLED = 0;
|
||||
var CONSTRUCT_INTERPOLATED = 2;
|
||||
var CONSTRUCT_STICHED = 3;
|
||||
var CONSTRUCT_POSTSCRIPT = 4;
|
||||
|
||||
return {
|
||||
getSampleArray: function PDFFunction_getSampleArray(size, outputSize, bps,
|
||||
str) {
|
||||
var i, ii;
|
||||
var length = 1;
|
||||
for (i = 0, ii = size.length; i < ii; i++) {
|
||||
length *= size[i];
|
||||
}
|
||||
length *= outputSize;
|
||||
|
||||
var array = [];
|
||||
var codeSize = 0;
|
||||
var codeBuf = 0;
|
||||
// 32 is a valid bps so shifting won't work
|
||||
var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);
|
||||
|
||||
var strBytes = str.getBytes((length * bps + 7) / 8);
|
||||
var strIdx = 0;
|
||||
for (i = 0; i < length; i++) {
|
||||
while (codeSize < bps) {
|
||||
codeBuf <<= 8;
|
||||
codeBuf |= strBytes[strIdx++];
|
||||
codeSize += 8;
|
||||
}
|
||||
codeSize -= bps;
|
||||
array.push((codeBuf >> codeSize) * sampleMul);
|
||||
codeBuf &= (1 << codeSize) - 1;
|
||||
}
|
||||
return array;
|
||||
},
|
||||
|
||||
getIR: function PDFFunction_getIR(xref, fn) {
|
||||
var dict = fn.dict;
|
||||
if (!dict) {
|
||||
dict = fn;
|
||||
}
|
||||
|
||||
var types = [this.constructSampled,
|
||||
null,
|
||||
this.constructInterpolated,
|
||||
this.constructStiched,
|
||||
this.constructPostScript];
|
||||
|
||||
var typeNum = dict.get('FunctionType');
|
||||
var typeFn = types[typeNum];
|
||||
if (!typeFn) {
|
||||
error('Unknown type of function');
|
||||
}
|
||||
|
||||
return typeFn.call(this, fn, dict, xref);
|
||||
},
|
||||
|
||||
fromIR: function PDFFunction_fromIR(IR) {
|
||||
var type = IR[0];
|
||||
switch (type) {
|
||||
case CONSTRUCT_SAMPLED:
|
||||
return this.constructSampledFromIR(IR);
|
||||
case CONSTRUCT_INTERPOLATED:
|
||||
return this.constructInterpolatedFromIR(IR);
|
||||
case CONSTRUCT_STICHED:
|
||||
return this.constructStichedFromIR(IR);
|
||||
//case CONSTRUCT_POSTSCRIPT:
|
||||
default:
|
||||
return this.constructPostScriptFromIR(IR);
|
||||
}
|
||||
},
|
||||
|
||||
parse: function PDFFunction_parse(xref, fn) {
|
||||
var IR = this.getIR(xref, fn);
|
||||
return this.fromIR(IR);
|
||||
},
|
||||
|
||||
constructSampled: function PDFFunction_constructSampled(str, dict) {
|
||||
function toMultiArray(arr) {
|
||||
var inputLength = arr.length;
|
||||
var out = [];
|
||||
var index = 0;
|
||||
for (var i = 0; i < inputLength; i += 2) {
|
||||
out[index] = [arr[i], arr[i + 1]];
|
||||
++index;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
var domain = dict.get('Domain');
|
||||
var range = dict.get('Range');
|
||||
|
||||
if (!domain || !range) {
|
||||
error('No domain or range');
|
||||
}
|
||||
|
||||
var inputSize = domain.length / 2;
|
||||
var outputSize = range.length / 2;
|
||||
|
||||
domain = toMultiArray(domain);
|
||||
range = toMultiArray(range);
|
||||
|
||||
var size = dict.get('Size');
|
||||
var bps = dict.get('BitsPerSample');
|
||||
var order = dict.get('Order') || 1;
|
||||
if (order !== 1) {
|
||||
// No description how cubic spline interpolation works in PDF32000:2008
|
||||
// As in poppler, ignoring order, linear interpolation may work as good
|
||||
info('No support for cubic spline interpolation: ' + order);
|
||||
}
|
||||
|
||||
var encode = dict.get('Encode');
|
||||
if (!encode) {
|
||||
encode = [];
|
||||
for (var i = 0; i < inputSize; ++i) {
|
||||
encode.push(0);
|
||||
encode.push(size[i] - 1);
|
||||
}
|
||||
}
|
||||
encode = toMultiArray(encode);
|
||||
|
||||
var decode = dict.get('Decode');
|
||||
if (!decode) {
|
||||
decode = range;
|
||||
} else {
|
||||
decode = toMultiArray(decode);
|
||||
}
|
||||
|
||||
var samples = this.getSampleArray(size, outputSize, bps, str);
|
||||
|
||||
return [
|
||||
CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size,
|
||||
outputSize, Math.pow(2, bps) - 1, range
|
||||
];
|
||||
},
|
||||
|
||||
constructSampledFromIR: function PDFFunction_constructSampledFromIR(IR) {
|
||||
// See chapter 3, page 109 of the PDF reference
|
||||
function interpolate(x, xmin, xmax, ymin, ymax) {
|
||||
return ymin + ((x - xmin) * ((ymax - ymin) / (xmax - xmin)));
|
||||
}
|
||||
|
||||
return function constructSampledFromIRResult(args) {
|
||||
// See chapter 3, page 110 of the PDF reference.
|
||||
var m = IR[1];
|
||||
var domain = IR[2];
|
||||
var encode = IR[3];
|
||||
var decode = IR[4];
|
||||
var samples = IR[5];
|
||||
var size = IR[6];
|
||||
var n = IR[7];
|
||||
//var mask = IR[8];
|
||||
var range = IR[9];
|
||||
|
||||
if (m != args.length) {
|
||||
error('Incorrect number of arguments: ' + m + ' != ' +
|
||||
args.length);
|
||||
}
|
||||
|
||||
var x = args;
|
||||
|
||||
// Building the cube vertices: its part and sample index
|
||||
// http://rjwagner49.com/Mathematics/Interpolation.pdf
|
||||
var cubeVertices = 1 << m;
|
||||
var cubeN = new Float64Array(cubeVertices);
|
||||
var cubeVertex = new Uint32Array(cubeVertices);
|
||||
var i, j;
|
||||
for (j = 0; j < cubeVertices; j++) {
|
||||
cubeN[j] = 1;
|
||||
}
|
||||
|
||||
var k = n, pos = 1;
|
||||
// Map x_i to y_j for 0 <= i < m using the sampled function.
|
||||
for (i = 0; i < m; ++i) {
|
||||
// x_i' = min(max(x_i, Domain_2i), Domain_2i+1)
|
||||
var domain_2i = domain[i][0];
|
||||
var domain_2i_1 = domain[i][1];
|
||||
var xi = Math.min(Math.max(x[i], domain_2i), domain_2i_1);
|
||||
|
||||
// e_i = Interpolate(x_i', Domain_2i, Domain_2i+1,
|
||||
// Encode_2i, Encode_2i+1)
|
||||
var e = interpolate(xi, domain_2i, domain_2i_1,
|
||||
encode[i][0], encode[i][1]);
|
||||
|
||||
// e_i' = min(max(e_i, 0), Size_i - 1)
|
||||
var size_i = size[i];
|
||||
e = Math.min(Math.max(e, 0), size_i - 1);
|
||||
|
||||
// Adjusting the cube: N and vertex sample index
|
||||
var e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1;
|
||||
var n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0);
|
||||
var n1 = e - e0; // (e - e0) / (e1 - e0);
|
||||
var offset0 = e0 * k;
|
||||
var offset1 = offset0 + k; // e1 * k
|
||||
for (j = 0; j < cubeVertices; j++) {
|
||||
if (j & pos) {
|
||||
cubeN[j] *= n1;
|
||||
cubeVertex[j] += offset1;
|
||||
} else {
|
||||
cubeN[j] *= n0;
|
||||
cubeVertex[j] += offset0;
|
||||
}
|
||||
}
|
||||
|
||||
k *= size_i;
|
||||
pos <<= 1;
|
||||
}
|
||||
|
||||
var y = new Float64Array(n);
|
||||
for (j = 0; j < n; ++j) {
|
||||
// Sum all cube vertices' samples portions
|
||||
var rj = 0;
|
||||
for (i = 0; i < cubeVertices; i++) {
|
||||
rj += samples[cubeVertex[i] + j] * cubeN[i];
|
||||
}
|
||||
|
||||
// r_j' = Interpolate(r_j, 0, 2^BitsPerSample - 1,
|
||||
// Decode_2j, Decode_2j+1)
|
||||
rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
|
||||
|
||||
// y_j = min(max(r_j, range_2j), range_2j+1)
|
||||
y[j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);
|
||||
}
|
||||
|
||||
return y;
|
||||
};
|
||||
},
|
||||
|
||||
constructInterpolated: function PDFFunction_constructInterpolated(str,
|
||||
dict) {
|
||||
var c0 = dict.get('C0') || [0];
|
||||
var c1 = dict.get('C1') || [1];
|
||||
var n = dict.get('N');
|
||||
|
||||
if (!isArray(c0) || !isArray(c1)) {
|
||||
error('Illegal dictionary for interpolated function');
|
||||
}
|
||||
|
||||
var length = c0.length;
|
||||
var diff = [];
|
||||
for (var i = 0; i < length; ++i) {
|
||||
diff.push(c1[i] - c0[i]);
|
||||
}
|
||||
|
||||
return [CONSTRUCT_INTERPOLATED, c0, diff, n];
|
||||
},
|
||||
|
||||
constructInterpolatedFromIR:
|
||||
function PDFFunction_constructInterpolatedFromIR(IR) {
|
||||
var c0 = IR[1];
|
||||
var diff = IR[2];
|
||||
var n = IR[3];
|
||||
|
||||
var length = diff.length;
|
||||
|
||||
return function constructInterpolatedFromIRResult(args) {
|
||||
var x = n == 1 ? args[0] : Math.pow(args[0], n);
|
||||
|
||||
var out = [];
|
||||
for (var j = 0; j < length; ++j) {
|
||||
out.push(c0[j] + (x * diff[j]));
|
||||
}
|
||||
|
||||
return out;
|
||||
|
||||
};
|
||||
},
|
||||
|
||||
constructStiched: function PDFFunction_constructStiched(fn, dict, xref) {
|
||||
var domain = dict.get('Domain');
|
||||
|
||||
if (!domain) {
|
||||
error('No domain');
|
||||
}
|
||||
|
||||
var inputSize = domain.length / 2;
|
||||
if (inputSize != 1) {
|
||||
error('Bad domain for stiched function');
|
||||
}
|
||||
|
||||
var fnRefs = dict.get('Functions');
|
||||
var fns = [];
|
||||
for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
|
||||
fns.push(PDFFunction.getIR(xref, xref.fetchIfRef(fnRefs[i])));
|
||||
}
|
||||
|
||||
var bounds = dict.get('Bounds');
|
||||
var encode = dict.get('Encode');
|
||||
|
||||
return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
|
||||
},
|
||||
|
||||
constructStichedFromIR: function PDFFunction_constructStichedFromIR(IR) {
|
||||
var domain = IR[1];
|
||||
var bounds = IR[2];
|
||||
var encode = IR[3];
|
||||
var fnsIR = IR[4];
|
||||
var fns = [];
|
||||
|
||||
for (var i = 0, ii = fnsIR.length; i < ii; i++) {
|
||||
fns.push(PDFFunction.fromIR(fnsIR[i]));
|
||||
}
|
||||
|
||||
return function constructStichedFromIRResult(args) {
|
||||
var clip = function constructStichedFromIRClip(v, min, max) {
|
||||
if (v > max) {
|
||||
v = max;
|
||||
} else if (v < min) {
|
||||
v = min;
|
||||
}
|
||||
return v;
|
||||
};
|
||||
|
||||
// clip to domain
|
||||
var v = clip(args[0], domain[0], domain[1]);
|
||||
// calulate which bound the value is in
|
||||
for (var i = 0, ii = bounds.length; i < ii; ++i) {
|
||||
if (v < bounds[i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// encode value into domain of function
|
||||
var dmin = domain[0];
|
||||
if (i > 0) {
|
||||
dmin = bounds[i - 1];
|
||||
}
|
||||
var dmax = domain[1];
|
||||
if (i < bounds.length) {
|
||||
dmax = bounds[i];
|
||||
}
|
||||
|
||||
var rmin = encode[2 * i];
|
||||
var rmax = encode[2 * i + 1];
|
||||
|
||||
var v2 = rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin);
|
||||
|
||||
// call the appropriate function
|
||||
return fns[i]([v2]);
|
||||
};
|
||||
},
|
||||
|
||||
constructPostScript: function PDFFunction_constructPostScript(fn, dict,
|
||||
xref) {
|
||||
var domain = dict.get('Domain');
|
||||
var range = dict.get('Range');
|
||||
|
||||
if (!domain) {
|
||||
error('No domain.');
|
||||
}
|
||||
|
||||
if (!range) {
|
||||
error('No range.');
|
||||
}
|
||||
|
||||
var lexer = new PostScriptLexer(fn);
|
||||
var parser = new PostScriptParser(lexer);
|
||||
var code = parser.parse();
|
||||
|
||||
return [CONSTRUCT_POSTSCRIPT, domain, range, code];
|
||||
},
|
||||
|
||||
constructPostScriptFromIR: function PDFFunction_constructPostScriptFromIR(
|
||||
IR) {
|
||||
var domain = IR[1];
|
||||
var range = IR[2];
|
||||
var code = IR[3];
|
||||
var numOutputs = range.length >> 1;
|
||||
var numInputs = domain.length >> 1;
|
||||
var evaluator = new PostScriptEvaluator(code);
|
||||
// Cache the values for a big speed up, the cache size is limited though
|
||||
// since the number of possible values can be huge from a PS function.
|
||||
var cache = {};
|
||||
// The MAX_CACHE_SIZE is set to ~4x the maximum number of distinct values
|
||||
// seen in our tests.
|
||||
var MAX_CACHE_SIZE = 2048 * 4;
|
||||
var cache_available = MAX_CACHE_SIZE;
|
||||
return function constructPostScriptFromIRResult(args) {
|
||||
var i, value;
|
||||
var key = '';
|
||||
var input = new Array(numInputs);
|
||||
for (i = 0; i < numInputs; i++) {
|
||||
value = args[i];
|
||||
input[i] = value;
|
||||
key += value + '_';
|
||||
}
|
||||
|
||||
var cachedValue = cache[key];
|
||||
if (cachedValue !== undefined) {
|
||||
return cachedValue;
|
||||
}
|
||||
|
||||
var output = new Array(numOutputs);
|
||||
var stack = evaluator.execute(input);
|
||||
var stackIndex = stack.length - numOutputs;
|
||||
for (i = 0; i < numOutputs; i++) {
|
||||
value = stack[stackIndex + i];
|
||||
var bound = range[i * 2];
|
||||
if (value < bound) {
|
||||
value = bound;
|
||||
} else {
|
||||
bound = range[i * 2 +1];
|
||||
if (value > bound) {
|
||||
value = bound;
|
||||
}
|
||||
}
|
||||
output[i] = value;
|
||||
}
|
||||
if (cache_available > 0) {
|
||||
cache_available--;
|
||||
cache[key] = output;
|
||||
}
|
||||
return output;
|
||||
};
|
||||
}
|
||||
};
|
||||
})();
|
||||
|
||||
var PostScriptStack = (function PostScriptStackClosure() {
|
||||
var MAX_STACK_SIZE = 100;
|
||||
function PostScriptStack(initialStack) {
|
||||
this.stack = initialStack || [];
|
||||
}
|
||||
|
||||
PostScriptStack.prototype = {
|
||||
push: function PostScriptStack_push(value) {
|
||||
if (this.stack.length >= MAX_STACK_SIZE) {
|
||||
error('PostScript function stack overflow.');
|
||||
}
|
||||
this.stack.push(value);
|
||||
},
|
||||
pop: function PostScriptStack_pop() {
|
||||
if (this.stack.length <= 0) {
|
||||
error('PostScript function stack underflow.');
|
||||
}
|
||||
return this.stack.pop();
|
||||
},
|
||||
copy: function PostScriptStack_copy(n) {
|
||||
if (this.stack.length + n >= MAX_STACK_SIZE) {
|
||||
error('PostScript function stack overflow.');
|
||||
}
|
||||
var stack = this.stack;
|
||||
for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
|
||||
stack.push(stack[i]);
|
||||
}
|
||||
},
|
||||
index: function PostScriptStack_index(n) {
|
||||
this.push(this.stack[this.stack.length - n - 1]);
|
||||
},
|
||||
// rotate the last n stack elements p times
|
||||
roll: function PostScriptStack_roll(n, p) {
|
||||
var stack = this.stack;
|
||||
var l = stack.length - n;
|
||||
var r = stack.length - 1, c = l + (p - Math.floor(p / n) * n), i, j, t;
|
||||
for (i = l, j = r; i < j; i++, j--) {
|
||||
t = stack[i]; stack[i] = stack[j]; stack[j] = t;
|
||||
}
|
||||
for (i = l, j = c - 1; i < j; i++, j--) {
|
||||
t = stack[i]; stack[i] = stack[j]; stack[j] = t;
|
||||
}
|
||||
for (i = c, j = r; i < j; i++, j--) {
|
||||
t = stack[i]; stack[i] = stack[j]; stack[j] = t;
|
||||
}
|
||||
}
|
||||
};
|
||||
return PostScriptStack;
|
||||
})();
|
||||
var PostScriptEvaluator = (function PostScriptEvaluatorClosure() {
|
||||
function PostScriptEvaluator(operators) {
|
||||
this.operators = operators;
|
||||
}
|
||||
PostScriptEvaluator.prototype = {
|
||||
execute: function PostScriptEvaluator_execute(initialStack) {
|
||||
var stack = new PostScriptStack(initialStack);
|
||||
var counter = 0;
|
||||
var operators = this.operators;
|
||||
var length = operators.length;
|
||||
var operator, a, b;
|
||||
while (counter < length) {
|
||||
operator = operators[counter++];
|
||||
if (typeof operator == 'number') {
|
||||
// Operator is really an operand and should be pushed to the stack.
|
||||
stack.push(operator);
|
||||
continue;
|
||||
}
|
||||
switch (operator) {
|
||||
// non standard ps operators
|
||||
case 'jz': // jump if false
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
if (!a) {
|
||||
counter = b;
|
||||
}
|
||||
break;
|
||||
case 'j': // jump
|
||||
a = stack.pop();
|
||||
counter = a;
|
||||
break;
|
||||
|
||||
// all ps operators in alphabetical order (excluding if/ifelse)
|
||||
case 'abs':
|
||||
a = stack.pop();
|
||||
stack.push(Math.abs(a));
|
||||
break;
|
||||
case 'add':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a + b);
|
||||
break;
|
||||
case 'and':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
if (isBool(a) && isBool(b)) {
|
||||
stack.push(a && b);
|
||||
} else {
|
||||
stack.push(a & b);
|
||||
}
|
||||
break;
|
||||
case 'atan':
|
||||
a = stack.pop();
|
||||
stack.push(Math.atan(a));
|
||||
break;
|
||||
case 'bitshift':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
if (a > 0) {
|
||||
stack.push(a << b);
|
||||
} else {
|
||||
stack.push(a >> b);
|
||||
}
|
||||
break;
|
||||
case 'ceiling':
|
||||
a = stack.pop();
|
||||
stack.push(Math.ceil(a));
|
||||
break;
|
||||
case 'copy':
|
||||
a = stack.pop();
|
||||
stack.copy(a);
|
||||
break;
|
||||
case 'cos':
|
||||
a = stack.pop();
|
||||
stack.push(Math.cos(a));
|
||||
break;
|
||||
case 'cvi':
|
||||
a = stack.pop() | 0;
|
||||
stack.push(a);
|
||||
break;
|
||||
case 'cvr':
|
||||
// noop
|
||||
break;
|
||||
case 'div':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a / b);
|
||||
break;
|
||||
case 'dup':
|
||||
stack.copy(1);
|
||||
break;
|
||||
case 'eq':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a == b);
|
||||
break;
|
||||
case 'exch':
|
||||
stack.roll(2, 1);
|
||||
break;
|
||||
case 'exp':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(Math.pow(a, b));
|
||||
break;
|
||||
case 'false':
|
||||
stack.push(false);
|
||||
break;
|
||||
case 'floor':
|
||||
a = stack.pop();
|
||||
stack.push(Math.floor(a));
|
||||
break;
|
||||
case 'ge':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a >= b);
|
||||
break;
|
||||
case 'gt':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a > b);
|
||||
break;
|
||||
case 'idiv':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push((a / b) | 0);
|
||||
break;
|
||||
case 'index':
|
||||
a = stack.pop();
|
||||
stack.index(a);
|
||||
break;
|
||||
case 'le':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a <= b);
|
||||
break;
|
||||
case 'ln':
|
||||
a = stack.pop();
|
||||
stack.push(Math.log(a));
|
||||
break;
|
||||
case 'log':
|
||||
a = stack.pop();
|
||||
stack.push(Math.log(a) / Math.LN10);
|
||||
break;
|
||||
case 'lt':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a < b);
|
||||
break;
|
||||
case 'mod':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a % b);
|
||||
break;
|
||||
case 'mul':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a * b);
|
||||
break;
|
||||
case 'ne':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a != b);
|
||||
break;
|
||||
case 'neg':
|
||||
a = stack.pop();
|
||||
stack.push(-a);
|
||||
break;
|
||||
case 'not':
|
||||
a = stack.pop();
|
||||
if (isBool(a)) {
|
||||
stack.push(!a);
|
||||
} else {
|
||||
stack.push(~a);
|
||||
}
|
||||
break;
|
||||
case 'or':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
if (isBool(a) && isBool(b)) {
|
||||
stack.push(a || b);
|
||||
} else {
|
||||
stack.push(a | b);
|
||||
}
|
||||
break;
|
||||
case 'pop':
|
||||
stack.pop();
|
||||
break;
|
||||
case 'roll':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.roll(a, b);
|
||||
break;
|
||||
case 'round':
|
||||
a = stack.pop();
|
||||
stack.push(Math.round(a));
|
||||
break;
|
||||
case 'sin':
|
||||
a = stack.pop();
|
||||
stack.push(Math.sin(a));
|
||||
break;
|
||||
case 'sqrt':
|
||||
a = stack.pop();
|
||||
stack.push(Math.sqrt(a));
|
||||
break;
|
||||
case 'sub':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
stack.push(a - b);
|
||||
break;
|
||||
case 'true':
|
||||
stack.push(true);
|
||||
break;
|
||||
case 'truncate':
|
||||
a = stack.pop();
|
||||
a = a < 0 ? Math.ceil(a) : Math.floor(a);
|
||||
stack.push(a);
|
||||
break;
|
||||
case 'xor':
|
||||
b = stack.pop();
|
||||
a = stack.pop();
|
||||
if (isBool(a) && isBool(b)) {
|
||||
stack.push(a != b);
|
||||
} else {
|
||||
stack.push(a ^ b);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
error('Unknown operator ' + operator);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return stack.stack;
|
||||
}
|
||||
};
|
||||
return PostScriptEvaluator;
|
||||
})();
|
||||
Loading…
Add table
Add a link
Reference in a new issue