summaryrefslogtreecommitdiff
path: root/pdf/pdf_function.c
diff options
context:
space:
mode:
Diffstat (limited to 'pdf/pdf_function.c')
-rw-r--r--pdf/pdf_function.c954
1 files changed, 477 insertions, 477 deletions
diff --git a/pdf/pdf_function.c b/pdf/pdf_function.c
index 3fdd6ac7..392b5c19 100644
--- a/pdf/pdf_function.c
+++ b/pdf/pdf_function.c
@@ -3,8 +3,8 @@
enum
{
- MAXN = FZ_MAXCOLORS,
- MAXM = FZ_MAXCOLORS,
+ MAXN = FZ_MAX_COLORS,
+ MAXM = FZ_MAX_COLORS,
};
typedef struct psobj_s psobj;
@@ -25,7 +25,7 @@ struct pdf_function_s
int n; /* number of output values */
float domain[MAXM][2]; /* even index : min value, odd index : max value */
float range[MAXN][2]; /* even index : min value, odd index : max value */
- int hasrange;
+ int has_range;
union
{
@@ -72,20 +72,20 @@ static inline float LERP(float x, float xmin, float xmax, float ymin, float ymax
* PostScript calculator
*/
-enum { PSBOOL, PSINT, PSREAL, PSOPERATOR, PSBLOCK };
+enum { PS_BOOL, PS_INT, PS_REAL, PS_OPERATOR, PS_BLOCK };
enum
{
- PSOABS, PSOADD, PSOAND, PSOATAN, PSOBITSHIFT, PSOCEILING,
- PSOCOPY, PSOCOS, PSOCVI, PSOCVR, PSODIV, PSODUP, PSOEQ,
- PSOEXCH, PSOEXP, PSOFALSE, PSOFLOOR, PSOGE, PSOGT, PSOIDIV,
- PSOINDEX, PSOLE, PSOLN, PSOLOG, PSOLT, PSOMOD, PSOMUL,
- PSONE, PSONEG, PSONOT, PSOOR, PSOPOP, PSOROLL, PSOROUND,
- PSOSIN, PSOSQRT, PSOSUB, PSOTRUE, PSOTRUNCATE, PSOXOR,
- PSOIF, PSOIFELSE, PSORETURN
+ PS_OP_ABS, PS_OP_ADD, PS_OP_AND, PS_OP_ATAN, PS_OP_BITSHIFT, PS_OP_CEILING,
+ PS_OP_COPY, PS_OP_COS, PS_OP_CVI, PS_OP_CVR, PS_OP_DIV, PS_OP_DUP, PS_OP_EQ,
+ PS_OP_EXCH, PS_OP_EXP, PS_OP_FALSE, PS_OP_FLOOR, PS_OP_GE, PS_OP_GT, PS_OP_IDIV,
+ PS_OP_INDEX, PS_OP_LE, PS_OP_LN, PS_OP_LOG, PS_OP_LT, PS_OP_MOD, PS_OP_MUL,
+ PS_OP_NE, PS_OP_NEG, PS_OP_NOT, PS_OP_OR, PS_OP_POP, PS_OP_ROLL, PS_OP_ROUND,
+ PS_OP_SIN, PS_OP_SQRT, PS_OP_SUB, PS_OP_TRUE, PS_OP_TRUNCATE, PS_OP_XOR,
+ PS_OP_IF, PS_OP_IFELSE, PS_OP_RETURN
};
-static char *psopnames[] =
+static char *ps_op_names[] =
{
"abs", "add", "and", "atan", "bitshift", "ceiling", "copy",
"cos", "cvi", "cvr", "div", "dup", "eq", "exch", "exp",
@@ -108,16 +108,16 @@ struct psobj_s
} u;
};
-typedef struct psstack_s psstack;
+typedef struct ps_stack_s ps_stack;
-struct psstack_s
+struct ps_stack_s
{
psobj stack[100];
int sp;
};
void
-pdf_debugpsstack(psstack *st)
+pdf_debug_ps_stack(ps_stack *st)
{
int i;
@@ -127,18 +127,18 @@ pdf_debugpsstack(psstack *st)
{
switch (st->stack[i].type)
{
- case PSBOOL:
+ case PS_BOOL:
if (st->stack[i].u.b)
printf("true ");
else
printf("false ");
break;
- case PSINT:
+ case PS_INT:
printf("%d ", st->stack[i].u.i);
break;
- case PSREAL:
+ case PS_REAL:
printf("%g ", st->stack[i].u.f);
break;
}
@@ -148,110 +148,110 @@ pdf_debugpsstack(psstack *st)
}
static void
-psinitstack(psstack *st)
+ps_init_stack(ps_stack *st)
{
memset(st->stack, 0, sizeof(st->stack));
st->sp = 0;
}
static inline int
-psoverflow(psstack *st, int n)
+ps_overflow(ps_stack *st, int n)
{
return n < 0 || st->sp + n >= nelem(st->stack);
}
static inline int
-psunderflow(psstack *st, int n)
+ps_underflow(ps_stack *st, int n)
{
return n < 0 || st->sp - n < 0;
}
static inline int
-psistype(psstack *st, int t)
+ps_is_type(ps_stack *st, int t)
{
- return !psunderflow(st, 1) && st->stack[st->sp - 1].type == t;
+ return !ps_underflow(st, 1) && st->stack[st->sp - 1].type == t;
}
static inline int
-psistype2(psstack *st, int t)
+ps_is_type2(ps_stack *st, int t)
{
- return !psunderflow(st, 2) && st->stack[st->sp - 1].type == t && st->stack[st->sp - 2].type == t;
+ return !ps_underflow(st, 2) && st->stack[st->sp - 1].type == t && st->stack[st->sp - 2].type == t;
}
static void
-pspushbool(psstack *st, int b)
+ps_push_bool(ps_stack *st, int b)
{
- if (!psoverflow(st, 1))
+ if (!ps_overflow(st, 1))
{
- st->stack[st->sp].type = PSBOOL;
+ st->stack[st->sp].type = PS_BOOL;
st->stack[st->sp].u.b = b;
st->sp++;
}
}
static void
-pspushint(psstack *st, int n)
+ps_push_int(ps_stack *st, int n)
{
- if (!psoverflow(st, 1))
+ if (!ps_overflow(st, 1))
{
- st->stack[st->sp].type = PSINT;
+ st->stack[st->sp].type = PS_INT;
st->stack[st->sp].u.i = n;
st->sp++;
}
}
static void
-pspushreal(psstack *st, float n)
+ps_push_real(ps_stack *st, float n)
{
- if (!psoverflow(st, 1))
+ if (!ps_overflow(st, 1))
{
- st->stack[st->sp].type = PSREAL;
+ st->stack[st->sp].type = PS_REAL;
st->stack[st->sp].u.f = n;
st->sp++;
}
}
static int
-pspopbool(psstack *st)
+ps_pop_bool(ps_stack *st)
{
- if (!psunderflow(st, 1))
+ if (!ps_underflow(st, 1))
{
- if (psistype(st, PSBOOL))
+ if (ps_is_type(st, PS_BOOL))
return st->stack[--st->sp].u.b;
}
return 0;
}
static int
-pspopint(psstack *st)
+ps_pop_int(ps_stack *st)
{
- if (!psunderflow(st, 1))
+ if (!ps_underflow(st, 1))
{
- if (psistype(st, PSINT))
+ if (ps_is_type(st, PS_INT))
return st->stack[--st->sp].u.i;
- if (psistype(st, PSREAL))
+ if (ps_is_type(st, PS_REAL))
return st->stack[--st->sp].u.f;
}
return 0;
}
static float
-pspopreal(psstack *st)
+ps_pop_real(ps_stack *st)
{
- if (!psunderflow(st, 1))
+ if (!ps_underflow(st, 1))
{
- if (psistype(st, PSINT))
+ if (ps_is_type(st, PS_INT))
return st->stack[--st->sp].u.i;
- if (psistype(st, PSREAL))
+ if (ps_is_type(st, PS_REAL))
return st->stack[--st->sp].u.f;
}
return 0;
}
static void
-pscopy(psstack *st, int n)
+ps_copy(ps_stack *st, int n)
{
- if (!psunderflow(st, n) && !psoverflow(st, n))
+ if (!ps_underflow(st, n) && !ps_overflow(st, n))
{
memcpy(st->stack + st->sp, st->stack + st->sp - n, n * sizeof(psobj));
st->sp += n;
@@ -259,12 +259,12 @@ pscopy(psstack *st, int n)
}
static void
-psroll(psstack *st, int n, int j)
+ps_roll(ps_stack *st, int n, int j)
{
psobj tmp;
int i;
- if (psunderflow(st, n) || j == 0 || n == 0)
+ if (ps_underflow(st, n) || j == 0 || n == 0)
return;
if (j >= 0)
@@ -287,9 +287,9 @@ psroll(psstack *st, int n, int j)
}
static void
-psindex(psstack *st, int n)
+ps_index(ps_stack *st, int n)
{
- if (!psoverflow(st, 1) && !psunderflow(st, n))
+ if (!ps_overflow(st, 1) && !ps_underflow(st, n))
{
st->stack[st->sp] = st->stack[st->sp - n - 1];
st->sp++;
@@ -297,7 +297,7 @@ psindex(psstack *st, int n)
}
static void
-psrun(psobj *code, psstack *st, int pc)
+ps_run(psobj *code, ps_stack *st, int pc)
{
int i1, i2;
float r1, r2;
@@ -307,357 +307,357 @@ psrun(psobj *code, psstack *st, int pc)
{
switch (code[pc].type)
{
- case PSINT:
- pspushint(st, code[pc++].u.i);
+ case PS_INT:
+ ps_push_int(st, code[pc++].u.i);
break;
- case PSREAL:
- pspushreal(st, code[pc++].u.f);
+ case PS_REAL:
+ ps_push_real(st, code[pc++].u.f);
break;
- case PSOPERATOR:
+ case PS_OPERATOR:
switch (code[pc++].u.op)
{
- case PSOABS:
- if (psistype(st, PSINT))
- pspushint(st, abs(pspopint(st)));
+ case PS_OP_ABS:
+ if (ps_is_type(st, PS_INT))
+ ps_push_int(st, abs(ps_pop_int(st)));
else
- pspushreal(st, fabsf(pspopreal(st)));
+ ps_push_real(st, fabsf(ps_pop_real(st)));
break;
- case PSOADD:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 + i2);
+ case PS_OP_ADD:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 + i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushreal(st, r1 + r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_real(st, r1 + r2);
}
break;
- case PSOAND:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 & i2);
+ case PS_OP_AND:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 & i2);
}
else {
- b2 = pspopbool(st);
- b1 = pspopbool(st);
- pspushbool(st, b1 && b2);
+ b2 = ps_pop_bool(st);
+ b1 = ps_pop_bool(st);
+ ps_push_bool(st, b1 && b2);
}
break;
- case PSOATAN:
- r2 = pspopreal(st);
- r1 = pspopreal(st);
+ case PS_OP_ATAN:
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
r1 = atan2f(r1, r2) * RADIAN;
if (r1 < 0)
r1 += 360;
- pspushreal(st, r1);
+ ps_push_real(st, r1);
break;
- case PSOBITSHIFT:
- i2 = pspopint(st);
- i1 = pspopint(st);
+ case PS_OP_BITSHIFT:
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
if (i2 > 0)
- pspushint(st, i1 << i2);
+ ps_push_int(st, i1 << i2);
else if (i2 < 0)
- pspushint(st, (int)((unsigned int)i1 >> i2));
+ ps_push_int(st, (int)((unsigned int)i1 >> i2));
else
- pspushint(st, i1);
+ ps_push_int(st, i1);
break;
- case PSOCEILING:
- r1 = pspopreal(st);
- pspushreal(st, ceilf(r1));
+ case PS_OP_CEILING:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, ceilf(r1));
break;
- case PSOCOPY:
- pscopy(st, pspopint(st));
+ case PS_OP_COPY:
+ ps_copy(st, ps_pop_int(st));
break;
- case PSOCOS:
- r1 = pspopreal(st);
- pspushreal(st, cosf(r1/RADIAN));
+ case PS_OP_COS:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, cosf(r1/RADIAN));
break;
- case PSOCVI:
- pspushint(st, pspopint(st));
+ case PS_OP_CVI:
+ ps_push_int(st, ps_pop_int(st));
break;
- case PSOCVR:
- pspushreal(st, pspopreal(st));
+ case PS_OP_CVR:
+ ps_push_real(st, ps_pop_real(st));
break;
- case PSODIV:
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushreal(st, r1 / r2);
+ case PS_OP_DIV:
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_real(st, r1 / r2);
break;
- case PSODUP:
- pscopy(st, 1);
+ case PS_OP_DUP:
+ ps_copy(st, 1);
break;
- case PSOEQ:
- if (psistype2(st, PSBOOL)) {
- b2 = pspopbool(st);
- b1 = pspopbool(st);
- pspushbool(st, b1 == b2);
+ case PS_OP_EQ:
+ if (ps_is_type2(st, PS_BOOL)) {
+ b2 = ps_pop_bool(st);
+ b1 = ps_pop_bool(st);
+ ps_push_bool(st, b1 == b2);
}
- else if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushbool(st, i1 == i2);
+ else if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_bool(st, i1 == i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushbool(st, r1 == r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_bool(st, r1 == r2);
}
break;
- case PSOEXCH:
- psroll(st, 2, 1);
+ case PS_OP_EXCH:
+ ps_roll(st, 2, 1);
break;
- case PSOEXP:
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushreal(st, powf(r1, r2));
+ case PS_OP_EXP:
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_real(st, powf(r1, r2));
break;
- case PSOFALSE:
- pspushbool(st, 0);
+ case PS_OP_FALSE:
+ ps_push_bool(st, 0);
break;
- case PSOFLOOR:
- r1 = pspopreal(st);
- pspushreal(st, floorf(r1));
+ case PS_OP_FLOOR:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, floorf(r1));
break;
- case PSOGE:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushbool(st, i1 >= i2);
+ case PS_OP_GE:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_bool(st, i1 >= i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushbool(st, r1 >= r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_bool(st, r1 >= r2);
}
break;
- case PSOGT:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushbool(st, i1 > i2);
+ case PS_OP_GT:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_bool(st, i1 > i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushbool(st, r1 > r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_bool(st, r1 > r2);
}
break;
- case PSOIDIV:
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 / i2);
+ case PS_OP_IDIV:
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 / i2);
break;
- case PSOINDEX:
- psindex(st, pspopint(st));
+ case PS_OP_INDEX:
+ ps_index(st, ps_pop_int(st));
break;
- case PSOLE:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushbool(st, i1 <= i2);
+ case PS_OP_LE:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_bool(st, i1 <= i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushbool(st, r1 <= r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_bool(st, r1 <= r2);
}
break;
- case PSOLN:
- r1 = pspopreal(st);
- pspushreal(st, logf(r1));
+ case PS_OP_LN:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, logf(r1));
break;
- case PSOLOG:
- r1 = pspopreal(st);
- pspushreal(st, log10f(r1));
+ case PS_OP_LOG:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, log10f(r1));
break;
- case PSOLT:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushbool(st, i1 < i2);
+ case PS_OP_LT:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_bool(st, i1 < i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushbool(st, r1 < r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_bool(st, r1 < r2);
}
break;
- case PSOMOD:
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 % i2);
+ case PS_OP_MOD:
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 % i2);
break;
- case PSOMUL:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 * i2);
+ case PS_OP_MUL:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 * i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushreal(st, r1 * r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_real(st, r1 * r2);
}
break;
- case PSONE:
- if (psistype2(st, PSBOOL)) {
- b2 = pspopbool(st);
- b1 = pspopbool(st);
- pspushbool(st, b1 != b2);
+ case PS_OP_NE:
+ if (ps_is_type2(st, PS_BOOL)) {
+ b2 = ps_pop_bool(st);
+ b1 = ps_pop_bool(st);
+ ps_push_bool(st, b1 != b2);
}
- else if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushbool(st, i1 != i2);
+ else if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_bool(st, i1 != i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushbool(st, r1 != r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_bool(st, r1 != r2);
}
break;
- case PSONEG:
- if (psistype(st, PSINT))
- pspushint(st, -pspopint(st));
+ case PS_OP_NEG:
+ if (ps_is_type(st, PS_INT))
+ ps_push_int(st, -ps_pop_int(st));
else
- pspushreal(st, -pspopreal(st));
+ ps_push_real(st, -ps_pop_real(st));
break;
- case PSONOT:
- if (psistype(st, PSBOOL))
- pspushbool(st, !pspopbool(st));
+ case PS_OP_NOT:
+ if (ps_is_type(st, PS_BOOL))
+ ps_push_bool(st, !ps_pop_bool(st));
else
- pspushint(st, ~pspopint(st));
+ ps_push_int(st, ~ps_pop_int(st));
break;
- case PSOOR:
- if (psistype2(st, PSBOOL)) {
- b2 = pspopbool(st);
- b1 = pspopbool(st);
- pspushbool(st, b1 || b2);
+ case PS_OP_OR:
+ if (ps_is_type2(st, PS_BOOL)) {
+ b2 = ps_pop_bool(st);
+ b1 = ps_pop_bool(st);
+ ps_push_bool(st, b1 || b2);
}
else {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 | i2);
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 | i2);
}
break;
- case PSOPOP:
- if (!psunderflow(st, 1))
+ case PS_OP_POP:
+ if (!ps_underflow(st, 1))
st->sp--;
break;
- case PSOROLL:
- i2 = pspopint(st);
- i1 = pspopint(st);
- psroll(st, i1, i2);
+ case PS_OP_ROLL:
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_roll(st, i1, i2);
break;
- case PSOROUND:
- if (!psistype(st, PSINT)) {
- r1 = pspopreal(st);
- pspushreal(st, (r1 >= 0) ? floorf(r1 + 0.5f) : ceilf(r1 - 0.5f));
+ case PS_OP_ROUND:
+ if (!ps_is_type(st, PS_INT)) {
+ r1 = ps_pop_real(st);
+ ps_push_real(st, (r1 >= 0) ? floorf(r1 + 0.5f) : ceilf(r1 - 0.5f));
}
break;
- case PSOSIN:
- r1 = pspopreal(st);
- pspushreal(st, sinf(r1/RADIAN));
+ case PS_OP_SIN:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, sinf(r1/RADIAN));
break;
- case PSOSQRT:
- r1 = pspopreal(st);
- pspushreal(st, sqrtf(r1));
+ case PS_OP_SQRT:
+ r1 = ps_pop_real(st);
+ ps_push_real(st, sqrtf(r1));
break;
- case PSOSUB:
- if (psistype2(st, PSINT)) {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 - i2);
+ case PS_OP_SUB:
+ if (ps_is_type2(st, PS_INT)) {
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 - i2);
}
else {
- r2 = pspopreal(st);
- r1 = pspopreal(st);
- pspushreal(st, r1 - r2);
+ r2 = ps_pop_real(st);
+ r1 = ps_pop_real(st);
+ ps_push_real(st, r1 - r2);
}
break;
- case PSOTRUE:
- pspushbool(st, 1);
+ case PS_OP_TRUE:
+ ps_push_bool(st, 1);
break;
- case PSOTRUNCATE:
- if (!psistype(st, PSINT)) {
- r1 = pspopreal(st);
- pspushreal(st, (r1 >= 0) ? floorf(r1) : ceilf(r1));
+ case PS_OP_TRUNCATE:
+ if (!ps_is_type(st, PS_INT)) {
+ r1 = ps_pop_real(st);
+ ps_push_real(st, (r1 >= 0) ? floorf(r1) : ceilf(r1));
}
break;
- case PSOXOR:
- if (psistype2(st, PSBOOL)) {
- b2 = pspopbool(st);
- b1 = pspopbool(st);
- pspushbool(st, b1 ^ b2);
+ case PS_OP_XOR:
+ if (ps_is_type2(st, PS_BOOL)) {
+ b2 = ps_pop_bool(st);
+ b1 = ps_pop_bool(st);
+ ps_push_bool(st, b1 ^ b2);
}
else {
- i2 = pspopint(st);
- i1 = pspopint(st);
- pspushint(st, i1 ^ i2);
+ i2 = ps_pop_int(st);
+ i1 = ps_pop_int(st);
+ ps_push_int(st, i1 ^ i2);
}
break;
- case PSOIF:
- b1 = pspopbool(st);
+ case PS_OP_IF:
+ b1 = ps_pop_bool(st);
if (b1)
- psrun(code, st, code[pc + 1].u.block);
+ ps_run(code, st, code[pc + 1].u.block);
pc = code[pc + 2].u.block;
break;
- case PSOIFELSE:
- b1 = pspopbool(st);
+ case PS_OP_IFELSE:
+ b1 = ps_pop_bool(st);
if (b1)
- psrun(code, st, code[pc + 1].u.block);
+ ps_run(code, st, code[pc + 1].u.block);
else
- psrun(code, st, code[pc + 0].u.block);
+ ps_run(code, st, code[pc + 0].u.block);
pc = code[pc + 2].u.block;
break;
- case PSORETURN:
+ case PS_OP_RETURN:
return;
default:
@@ -674,7 +674,7 @@ psrun(psobj *code, psstack *st, int pc)
}
static void
-resizecode(pdf_function *func, int newsize)
+resize_code(pdf_function *func, int newsize)
{
if (newsize >= func->u.p.cap)
{
@@ -684,7 +684,7 @@ resizecode(pdf_function *func, int newsize)
}
static fz_error
-parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
+parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
{
fz_error error;
char buf[64];
@@ -703,31 +703,31 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
switch(tok)
{
- case PDF_TEOF:
+ case PDF_TOK_EOF:
return fz_throw("truncated calculator function");
- case PDF_TINT:
- resizecode(func, *codeptr);
- func->u.p.code[*codeptr].type = PSINT;
+ case PDF_TOK_INT:
+ resize_code(func, *codeptr);
+ func->u.p.code[*codeptr].type = PS_INT;
func->u.p.code[*codeptr].u.i = atoi(buf);
++*codeptr;
break;
- case PDF_TREAL:
- resizecode(func, *codeptr);
- func->u.p.code[*codeptr].type = PSREAL;
+ case PDF_TOK_REAL:
+ resize_code(func, *codeptr);
+ func->u.p.code[*codeptr].type = PS_REAL;
func->u.p.code[*codeptr].u.f = atof(buf);
++*codeptr;
break;
- case PDF_TOBRACE:
+ case PDF_TOK_OPEN_BRACE:
opptr = *codeptr;
*codeptr += 4;
- resizecode(func, *codeptr);
+ resize_code(func, *codeptr);
ifptr = *codeptr;
- error = parsecode(func, stream, codeptr);
+ error = parse_code(func, stream, codeptr);
if (error)
return fz_rethrow(error, "error in 'if' branch");
@@ -735,10 +735,10 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
if (error)
return fz_rethrow(error, "calculator function syntax error");
- if (tok == PDF_TOBRACE)
+ if (tok == PDF_TOK_OPEN_BRACE)
{
elseptr = *codeptr;
- error = parsecode(func, stream, codeptr);
+ error = parse_code(func, stream, codeptr);
if (error)
return fz_rethrow(error, "error in 'else' branch");
@@ -751,30 +751,30 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
elseptr = -1;
}
- if (tok == PDF_TKEYWORD)
+ if (tok == PDF_TOK_KEYWORD)
{
if (!strcmp(buf, "if"))
{
if (elseptr >= 0)
return fz_throw("too many branches for 'if'");
- func->u.p.code[opptr].type = PSOPERATOR;
- func->u.p.code[opptr].u.op = PSOIF;
- func->u.p.code[opptr+2].type = PSBLOCK;
+ func->u.p.code[opptr].type = PS_OPERATOR;
+ func->u.p.code[opptr].u.op = PS_OP_IF;
+ func->u.p.code[opptr+2].type = PS_BLOCK;
func->u.p.code[opptr+2].u.block = ifptr;
- func->u.p.code[opptr+3].type = PSBLOCK;
+ func->u.p.code[opptr+3].type = PS_BLOCK;
func->u.p.code[opptr+3].u.block = *codeptr;
}
else if (!strcmp(buf, "ifelse"))
{
if (elseptr < 0)
return fz_throw("not enough branches for 'ifelse'");
- func->u.p.code[opptr].type = PSOPERATOR;
- func->u.p.code[opptr].u.op = PSOIFELSE;
- func->u.p.code[opptr+1].type = PSBLOCK;
+ func->u.p.code[opptr].type = PS_OPERATOR;
+ func->u.p.code[opptr].u.op = PS_OP_IFELSE;
+ func->u.p.code[opptr+1].type = PS_BLOCK;
func->u.p.code[opptr+1].u.block = elseptr;
- func->u.p.code[opptr+2].type = PSBLOCK;
+ func->u.p.code[opptr+2].type = PS_BLOCK;
func->u.p.code[opptr+2].u.block = ifptr;
- func->u.p.code[opptr+3].type = PSBLOCK;
+ func->u.p.code[opptr+3].type = PS_BLOCK;
func->u.p.code[opptr+3].u.block = *codeptr;
}
else
@@ -788,21 +788,21 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
}
break;
- case PDF_TCBRACE:
- resizecode(func, *codeptr);
- func->u.p.code[*codeptr].type = PSOPERATOR;
- func->u.p.code[*codeptr].u.op = PSORETURN;
+ case PDF_TOK_CLOSE_BRACE:
+ resize_code(func, *codeptr);
+ func->u.p.code[*codeptr].type = PS_OPERATOR;
+ func->u.p.code[*codeptr].u.op = PS_OP_RETURN;
++*codeptr;
return fz_okay;
- case PDF_TKEYWORD:
+ case PDF_TOK_KEYWORD:
cmp = -1;
a = -1;
- b = nelem(psopnames);
+ b = nelem(ps_op_names);
while (b - a > 1)
{
mid = (a + b) / 2;
- cmp = strcmp(buf, psopnames[mid]);
+ cmp = strcmp(buf, ps_op_names[mid]);
if (cmp > 0)
a = mid;
else if (cmp < 0)
@@ -813,8 +813,8 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
if (cmp != 0)
return fz_throw("unknown operator: '%s'", buf);
- resizecode(func, *codeptr);
- func->u.p.code[*codeptr].type = PSOPERATOR;
+ resize_code(func, *codeptr);
+ func->u.p.code[*codeptr].type = PS_OPERATOR;
func->u.p.code[*codeptr].u.op = a;
++*codeptr;
break;
@@ -826,7 +826,7 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
}
static fz_error
-loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int gen)
+load_postscript_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int gen)
{
fz_error error;
fz_stream *stream;
@@ -835,9 +835,9 @@ loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, in
int tok;
int len;
- pdf_logrsrc("load postscript function (%d %d R)\n", num, gen);
+ pdf_log_rsrc("load postscript function (%d %d R)\n", num, gen);
- error = pdf_openstream(&stream, xref, num, gen);
+ error = pdf_open_stream(&stream, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot open calculator function stream");
@@ -848,17 +848,17 @@ loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, in
return fz_rethrow(error, "stream is not a calculator function");
}
- if (tok != PDF_TOBRACE)
+ if (tok != PDF_TOK_OPEN_BRACE)
{
fz_close(stream);
return fz_throw("stream is not a calculator function");
}
- func->u.p.code = nil;
+ func->u.p.code = NULL;
func->u.p.cap = 0;
codeptr = 0;
- error = parsecode(func, stream, &codeptr);
+ error = parse_code(func, stream, &codeptr);
if (error)
{
fz_close(stream);
@@ -870,25 +870,25 @@ loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, in
}
static void
-evalpostscriptfunc(pdf_function *func, float *in, float *out)
+eval_postscript_func(pdf_function *func, float *in, float *out)
{
- psstack st;
+ ps_stack st;
float x;
int i;
- psinitstack(&st);
+ ps_init_stack(&st);
for (i = 0; i < func->m; i++)
{
x = CLAMP(in[i], func->domain[i][0], func->domain[i][1]);
- pspushreal(&st, x);
+ ps_push_real(&st, x);
}
- psrun(func->u.p.code, &st, 0);
+ ps_run(func->u.p.code, &st, 0);
for (i = func->n - 1; i >= 0; i--)
{
- x = pspopreal(&st);
+ x = ps_pop_real(&st);
out[i] = CLAMP(x, func->range[i][0], func->range[i][1]);
}
}
@@ -898,7 +898,7 @@ evalpostscriptfunc(pdf_function *func, float *in, float *out)
*/
static fz_error
-loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int gen)
+load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int gen)
{
fz_error error;
fz_stream *stream;
@@ -907,32 +907,32 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int ge
int bps;
int i;
- pdf_logrsrc("sampled function {\n");
+ pdf_log_rsrc("sampled function {\n");
- func->u.sa.samples = nil;
+ func->u.sa.samples = NULL;
- obj = fz_dictgets(dict, "Size");
- if (!fz_isarray(obj) || fz_arraylen(obj) != func->m)
+ obj = fz_dict_gets(dict, "Size");
+ if (!fz_is_array(obj) || fz_array_len(obj) != func->m)
return fz_throw("malformed /Size");
for (i = 0; i < func->m; i++)
- func->u.sa.size[i] = fz_toint(fz_arrayget(obj, i));
+ func->u.sa.size[i] = fz_to_int(fz_array_get(obj, i));
- obj = fz_dictgets(dict, "BitsPerSample");
- if (!fz_isint(obj))
+ obj = fz_dict_gets(dict, "BitsPerSample");
+ if (!fz_is_int(obj))
return fz_throw("malformed /BitsPerSample");
- func->u.sa.bps = bps = fz_toint(obj);
+ func->u.sa.bps = bps = fz_to_int(obj);
- pdf_logrsrc("bps %d\n", bps);
+ pdf_log_rsrc("bps %d\n", bps);
- obj = fz_dictgets(dict, "Encode");
- if (fz_isarray(obj))
+ obj = fz_dict_gets(dict, "Encode");
+ if (fz_is_array(obj))
{
- if (fz_arraylen(obj) != func->m * 2)
+ if (fz_array_len(obj) != func->m * 2)
return fz_throw("malformed /Encode");
for (i = 0; i < func->m; i++)
{
- func->u.sa.encode[i][0] = fz_toreal(fz_arrayget(obj, i*2+0));
- func->u.sa.encode[i][1] = fz_toreal(fz_arrayget(obj, i*2+1));
+ func->u.sa.encode[i][0] = fz_to_real(fz_array_get(obj, i*2+0));
+ func->u.sa.encode[i][1] = fz_to_real(fz_array_get(obj, i*2+1));
}
}
else
@@ -944,15 +944,15 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int ge
}
}
- obj = fz_dictgets(dict, "Decode");
- if (fz_isarray(obj))
+ obj = fz_dict_gets(dict, "Decode");
+ if (fz_is_array(obj))
{
- if (fz_arraylen(obj) != func->n * 2)
+ if (fz_array_len(obj) != func->n * 2)
return fz_throw("malformed /Decode");
for (i = 0; i < func->n; i++)
{
- func->u.sa.decode[i][0] = fz_toreal(fz_arrayget(obj, i*2+0));
- func->u.sa.decode[i][1] = fz_toreal(fz_arrayget(obj, i*2+1));
+ func->u.sa.decode[i][0] = fz_to_real(fz_array_get(obj, i*2+0));
+ func->u.sa.decode[i][1] = fz_to_real(fz_array_get(obj, i*2+1));
}
}
else
@@ -967,11 +967,11 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int ge
for (i = 0, samplecount = func->n; i < func->m; i++)
samplecount *= func->u.sa.size[i];
- pdf_logrsrc("samplecount %d\n", samplecount);
+ pdf_log_rsrc("samplecount %d\n", samplecount);
func->u.sa.samples = fz_calloc(samplecount, sizeof(float));
- error = pdf_openstream(&stream, xref, num, gen);
+ error = pdf_open_stream(&stream, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot open samples stream (%d %d R)", num, gen);
@@ -981,7 +981,7 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int ge
unsigned int x;
float s;
- if (fz_iseofbits(stream))
+ if (fz_is_eof_bits(stream))
{
fz_close(stream);
return fz_throw("truncated sample stream");
@@ -989,27 +989,27 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int ge
switch (bps)
{
- case 1: s = fz_readbits(stream, 1); break;
- case 2: s = fz_readbits(stream, 2) / 3.0f; break;
- case 4: s = fz_readbits(stream, 4) / 15.0f; break;
- case 8: s = fz_readbyte(stream) / 255.0f; break;
- case 12: s = fz_readbits(stream, 12) / 4095.0f; break;
+ case 1: s = fz_read_bits(stream, 1); break;
+ case 2: s = fz_read_bits(stream, 2) / 3.0f; break;
+ case 4: s = fz_read_bits(stream, 4) / 15.0f; break;
+ case 8: s = fz_read_byte(stream) / 255.0f; break;
+ case 12: s = fz_read_bits(stream, 12) / 4095.0f; break;
case 16:
- x = fz_readbyte(stream) << 8;
- x |= fz_readbyte(stream);
+ x = fz_read_byte(stream) << 8;
+ x |= fz_read_byte(stream);
s = x / 65535.0f;
break;
case 24:
- x = fz_readbyte(stream) << 16;
- x |= fz_readbyte(stream) << 8;
- x |= fz_readbyte(stream);
+ x = fz_read_byte(stream) << 16;
+ x |= fz_read_byte(stream) << 8;
+ x |= fz_read_byte(stream);
s = x / 16777215.0f;
break;
case 32:
- x = fz_readbyte(stream) << 24;
- x |= fz_readbyte(stream) << 16;
- x |= fz_readbyte(stream) << 8;
- x |= fz_readbyte(stream);
+ x = fz_read_byte(stream) << 24;
+ x |= fz_read_byte(stream) << 16;
+ x |= fz_read_byte(stream) << 8;
+ x |= fz_read_byte(stream);
s = x / 4294967295.0f;
break;
default:
@@ -1022,13 +1022,13 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int ge
fz_close(stream);
- pdf_logrsrc("}\n");
+ pdf_log_rsrc("}\n");
return fz_okay;
}
static float
-interpolatesample(pdf_function *func, int *scale, int *e0, int *e1, float *efrac, int dim, int idx)
+interpolate_sample(pdf_function *func, int *scale, int *e0, int *e1, float *efrac, int dim, int idx)
{
float a, b;
int idx0, idx1;
@@ -1043,15 +1043,15 @@ interpolatesample(pdf_function *func, int *scale, int *e0, int *e1, float *efrac
}
else
{
- a = interpolatesample(func, scale, e0, e1, efrac, dim - 1, idx0);
- b = interpolatesample(func, scale, e0, e1, efrac, dim - 1, idx1);
+ a = interpolate_sample(func, scale, e0, e1, efrac, dim - 1, idx0);
+ b = interpolate_sample(func, scale, e0, e1, efrac, dim - 1, idx1);
}
return a + (b - a) * efrac[dim];
}
static void
-evalsamplefunc(pdf_function *func, float *in, float *out)
+eval_sample_func(pdf_function *func, float *in, float *out)
{
int e0[MAXM], e1[MAXM], scale[MAXM];
float efrac[MAXM];
@@ -1107,7 +1107,7 @@ evalsamplefunc(pdf_function *func, float *in, float *out)
else
{
- float x = interpolatesample(func, scale, e0, e1, efrac, func->m - 1, i);
+ float x = interpolate_sample(func, scale, e0, e1, efrac, func->m - 1, i);
out[i] = LERP(x, 0, 1, func->u.sa.decode[i][0], func->u.sa.decode[i][1]);
out[i] = CLAMP(out[i], func->range[i][0], func->range[i][1]);
}
@@ -1119,31 +1119,31 @@ evalsamplefunc(pdf_function *func, float *in, float *out)
*/
static fz_error
-loadexponentialfunc(pdf_function *func, fz_obj *dict)
+load_exponential_func(pdf_function *func, fz_obj *dict)
{
fz_obj *obj;
int i;
- pdf_logrsrc("exponential function {\n");
+ pdf_log_rsrc("exponential function {\n");
if (func->m != 1)
return fz_throw("/Domain must be one dimension (%d)", func->m);
- obj = fz_dictgets(dict, "N");
- if (!fz_isint(obj) && !fz_isreal(obj))
+ obj = fz_dict_gets(dict, "N");
+ if (!fz_is_int(obj) && !fz_is_real(obj))
return fz_throw("malformed /N");
- func->u.e.n = fz_toreal(obj);
- pdf_logrsrc("n %g\n", func->u.e.n);
+ func->u.e.n = fz_to_real(obj);
+ pdf_log_rsrc("n %g\n", func->u.e.n);
- obj = fz_dictgets(dict, "C0");
- if (fz_isarray(obj))
+ obj = fz_dict_gets(dict, "C0");
+ if (fz_is_array(obj))
{
- func->n = fz_arraylen(obj);
+ func->n = fz_array_len(obj);
if (func->n >= MAXN)
return fz_throw("exponential function result array out of range");
for (i = 0; i < func->n; i++)
- func->u.e.c0[i] = fz_toreal(fz_arrayget(obj, i));
- pdf_logrsrc("c0 %d\n", func->n);
+ func->u.e.c0[i] = fz_to_real(fz_array_get(obj, i));
+ pdf_log_rsrc("c0 %d\n", func->n);
}
else
{
@@ -1151,14 +1151,14 @@ loadexponentialfunc(pdf_function *func, fz_obj *dict)
func->u.e.c0[0] = 0;
}
- obj = fz_dictgets(dict, "C1");
- if (fz_isarray(obj))
+ obj = fz_dict_gets(dict, "C1");
+ if (fz_is_array(obj))
{
- if (fz_arraylen(obj) != func->n)
+ if (fz_array_len(obj) != func->n)
return fz_throw("/C1 must match /C0 length");
for (i = 0; i < func->n; i++)
- func->u.e.c1[i] = fz_toreal(fz_arrayget(obj, i));
- pdf_logrsrc("c1 %d\n", func->n);
+ func->u.e.c1[i] = fz_to_real(fz_array_get(obj, i));
+ pdf_log_rsrc("c1 %d\n", func->n);
}
else
{
@@ -1167,13 +1167,13 @@ loadexponentialfunc(pdf_function *func, fz_obj *dict)
func->u.e.c1[0] = 1;
}
- pdf_logrsrc("}\n");
+ pdf_log_rsrc("}\n");
return fz_okay;
}
static void
-evalexponentialfunc(pdf_function *func, float in, float *out)
+eval_exponential_func(pdf_function *func, float in, float *out)
{
float x = in;
float tmp;
@@ -1192,7 +1192,7 @@ evalexponentialfunc(pdf_function *func, float in, float *out)
for (i = 0; i < func->n; i++)
{
out[i] = func->u.e.c0[i] + tmp * (func->u.e.c1[i] - func->u.e.c0[i]);
- if (func->hasrange)
+ if (func->has_range)
out[i] = CLAMP(out[i], func->range[i][0], func->range[i][1]);
}
}
@@ -1202,7 +1202,7 @@ evalexponentialfunc(pdf_function *func, float in, float *out)
*/
static fz_error
-loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
+load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
{
pdf_function **funcs;
fz_error error;
@@ -1212,20 +1212,20 @@ loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
int k;
int i;
- pdf_logrsrc("stitching {\n");
+ pdf_log_rsrc("stitching {\n");
func->u.st.k = 0;
if (func->m != 1)
return fz_throw("/Domain must be one dimension (%d)", func->m);
- obj = fz_dictgets(dict, "Functions");
- if (!fz_isarray(obj))
+ obj = fz_dict_gets(dict, "Functions");
+ if (!fz_is_array(obj))
return fz_throw("stitching function has no input functions");
{
- k = fz_arraylen(obj);
+ k = fz_array_len(obj);
- pdf_logrsrc("k %d\n", k);
+ pdf_log_rsrc("k %d\n", k);
func->u.st.funcs = fz_calloc(k, sizeof(pdf_function*));
func->u.st.bounds = fz_calloc(k - 1, sizeof(float));
@@ -1234,10 +1234,10 @@ loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
for (i = 0; i < k; i++)
{
- sub = fz_arrayget(obj, i);
- error = pdf_loadfunction(&funcs[i], xref, sub);
+ sub = fz_array_get(obj, i);
+ error = pdf_load_function(&funcs[i], xref, sub);
if (error)
- return fz_rethrow(error, "cannot load sub function %d (%d %d R)", i, fz_tonum(sub), fz_togen(sub));
+ return fz_rethrow(error, "cannot load sub function %d (%d %d R)", i, fz_to_num(sub), fz_to_gen(sub));
if (funcs[i]->m != 1 || funcs[i]->n != funcs[0]->n)
return fz_throw("sub function %d /Domain or /Range mismatch", i);
func->u.st.k ++;
@@ -1249,19 +1249,19 @@ loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
return fz_throw("sub function /Domain or /Range mismatch");
}
- obj = fz_dictgets(dict, "Bounds");
- if (!fz_isarray(obj))
+ obj = fz_dict_gets(dict, "Bounds");
+ if (!fz_is_array(obj))
return fz_throw("stitching function has no bounds");
{
- if (!fz_isarray(obj) || fz_arraylen(obj) != k - 1)
+ if (!fz_is_array(obj) || fz_array_len(obj) != k - 1)
return fz_throw("malformed /Bounds (not array or wrong length)");
for (i = 0; i < k-1; i++)
{
- num = fz_arrayget(obj, i);
- if (!fz_isint(num) && !fz_isreal(num))
+ num = fz_array_get(obj, i);
+ if (!fz_is_int(num) && !fz_is_real(num))
return fz_throw("malformed /Bounds (item not real)");
- func->u.st.bounds[i] = fz_toreal(num);
+ func->u.st.bounds[i] = fz_to_real(num);
if (i && func->u.st.bounds[i-1] > func->u.st.bounds[i])
return fz_throw("malformed /Bounds (item not monotonic)");
}
@@ -1271,26 +1271,26 @@ loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
fz_warn("malformed shading function bounds (domain mismatch), proceeding anyway.");
}
- obj = fz_dictgets(dict, "Encode");
- if (!fz_isarray(obj))
+ obj = fz_dict_gets(dict, "Encode");
+ if (!fz_is_array(obj))
return fz_throw("stitching function is missing encoding");
{
- if (!fz_isarray(obj) || fz_arraylen(obj) != k * 2)
+ if (!fz_is_array(obj) || fz_array_len(obj) != k * 2)
return fz_throw("malformed /Encode");
for (i = 0; i < k; i++)
{
- func->u.st.encode[i*2+0] = fz_toreal(fz_arrayget(obj, i*2+0));
- func->u.st.encode[i*2+1] = fz_toreal(fz_arrayget(obj, i*2+1));
+ func->u.st.encode[i*2+0] = fz_to_real(fz_array_get(obj, i*2+0));
+ func->u.st.encode[i*2+1] = fz_to_real(fz_array_get(obj, i*2+1));
}
}
- pdf_logrsrc("}\n");
+ pdf_log_rsrc("}\n");
return fz_okay;
}
static void
-evalstitchingfunc(pdf_function *func, float in, float *out)
+eval_stitching_func(pdf_function *func, float in, float *out)
{
float low, high;
int k = func->u.st.k;
@@ -1328,7 +1328,7 @@ evalstitchingfunc(pdf_function *func, float in, float *out)
in = LERP(in, low, high, func->u.st.encode[i*2+0], func->u.st.encode[i*2+1]);
- pdf_evalfunction(func->u.st.funcs[i], &in, 1, out, func->n);
+ pdf_eval_function(func->u.st.funcs[i], &in, 1, out, func->n);
}
/*
@@ -1336,14 +1336,14 @@ evalstitchingfunc(pdf_function *func, float in, float *out)
*/
pdf_function *
-pdf_keepfunction(pdf_function *func)
+pdf_keep_function(pdf_function *func)
{
func->refs ++;
return func;
}
void
-pdf_dropfunction(pdf_function *func)
+pdf_drop_function(pdf_function *func)
{
int i;
if (--func->refs == 0)
@@ -1357,7 +1357,7 @@ pdf_dropfunction(pdf_function *func)
break;
case STITCHING:
for (i = 0; i < func->u.st.k; i++)
- pdf_dropfunction(func->u.st.funcs[i]);
+ pdf_drop_function(func->u.st.funcs[i]);
fz_free(func->u.st.funcs);
fz_free(func->u.st.bounds);
fz_free(func->u.st.encode);
@@ -1371,56 +1371,56 @@ pdf_dropfunction(pdf_function *func)
}
fz_error
-pdf_loadfunction(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
+pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
pdf_function *func;
fz_obj *obj;
int i;
- if ((*funcp = pdf_finditem(xref->store, pdf_dropfunction, dict)))
+ if ((*funcp = pdf_find_item(xref->store, pdf_drop_function, dict)))
{
- pdf_keepfunction(*funcp);
+ pdf_keep_function(*funcp);
return fz_okay;
}
- pdf_logrsrc("load function (%d %d R) {\n", fz_tonum(dict), fz_togen(dict));
+ pdf_log_rsrc("load function (%d %d R) {\n", fz_to_num(dict), fz_to_gen(dict));
func = fz_malloc(sizeof(pdf_function));
memset(func, 0, sizeof(pdf_function));
func->refs = 1;
- obj = fz_dictgets(dict, "FunctionType");
- func->type = fz_toint(obj);
+ obj = fz_dict_gets(dict, "FunctionType");
+ func->type = fz_to_int(obj);
- pdf_logrsrc("type %d\n", func->type);
+ pdf_log_rsrc("type %d\n", func->type);
/* required for all */
- obj = fz_dictgets(dict, "Domain");
- func->m = fz_arraylen(obj) / 2;
+ obj = fz_dict_gets(dict, "Domain");
+ func->m = fz_array_len(obj) / 2;
for (i = 0; i < func->m; i++)
{
- func->domain[i][0] = fz_toreal(fz_arrayget(obj, i * 2 + 0));
- func->domain[i][1] = fz_toreal(fz_arrayget(obj, i * 2 + 1));
+ func->domain[i][0] = fz_to_real(fz_array_get(obj, i * 2 + 0));
+ func->domain[i][1] = fz_to_real(fz_array_get(obj, i * 2 + 1));
}
- pdf_logrsrc("domain %d\n", func->m);
+ pdf_log_rsrc("domain %d\n", func->m);
/* required for type0 and type4, optional otherwise */
- obj = fz_dictgets(dict, "Range");
- if (fz_isarray(obj))
+ obj = fz_dict_gets(dict, "Range");
+ if (fz_is_array(obj))
{
- func->hasrange = 1;
- func->n = fz_arraylen(obj) / 2;
+ func->has_range = 1;
+ func->n = fz_array_len(obj) / 2;
for (i = 0; i < func->n; i++)
{
- func->range[i][0] = fz_toreal(fz_arrayget(obj, i * 2 + 0));
- func->range[i][1] = fz_toreal(fz_arrayget(obj, i * 2 + 1));
+ func->range[i][0] = fz_to_real(fz_array_get(obj, i * 2 + 0));
+ func->range[i][1] = fz_to_real(fz_array_get(obj, i * 2 + 1));
}
- pdf_logrsrc("range %d\n", func->n);
+ pdf_log_rsrc("range %d\n", func->n);
}
else
{
- func->hasrange = 0;
+ func->has_range = 0;
func->n = 0;
}
@@ -1433,56 +1433,56 @@ pdf_loadfunction(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
switch(func->type)
{
case SAMPLE:
- error = loadsamplefunc(func, xref, dict, fz_tonum(dict), fz_togen(dict));
+ error = load_sample_func(func, xref, dict, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
- pdf_dropfunction(func);
- return fz_rethrow(error, "cannot load sampled function (%d %d R)", fz_tonum(dict), fz_togen(dict));
+ pdf_drop_function(func);
+ return fz_rethrow(error, "cannot load sampled function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
break;
case EXPONENTIAL:
- error = loadexponentialfunc(func, dict);
+ error = load_exponential_func(func, dict);
if (error)
{
- pdf_dropfunction(func);
- return fz_rethrow(error, "cannot load exponential function (%d %d R)", fz_tonum(dict), fz_togen(dict));
+ pdf_drop_function(func);
+ return fz_rethrow(error, "cannot load exponential function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
break;
case STITCHING:
- error = loadstitchingfunc(func, xref, dict);
+ error = load_stitching_func(func, xref, dict);
if (error)
{
- pdf_dropfunction(func);
- return fz_rethrow(error, "cannot load stitching function (%d %d R)", fz_tonum(dict), fz_togen(dict));
+ pdf_drop_function(func);
+ return fz_rethrow(error, "cannot load stitching function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
break;
case POSTSCRIPT:
- error = loadpostscriptfunc(func, xref, dict, fz_tonum(dict), fz_togen(dict));
+ error = load_postscript_func(func, xref, dict, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
- pdf_dropfunction(func);
- return fz_rethrow(error, "cannot load calculator function (%d %d R)", fz_tonum(dict), fz_togen(dict));
+ pdf_drop_function(func);
+ return fz_rethrow(error, "cannot load calculator function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
break;
default:
fz_free(func);
- return fz_throw("unknown function type (%d %d R)", fz_tonum(dict), fz_togen(dict));
+ return fz_throw("unknown function type (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
- pdf_logrsrc("}\n");
+ pdf_log_rsrc("}\n");
- pdf_storeitem(xref->store, pdf_keepfunction, pdf_dropfunction, dict, func);
+ pdf_store_item(xref->store, pdf_keep_function, pdf_drop_function, dict, func);
*funcp = func;
return fz_okay;
}
void
-pdf_evalfunction(pdf_function *func, float *in, int inlen, float *out, int outlen)
+pdf_eval_function(pdf_function *func, float *in, int inlen, float *out, int outlen)
{
memset(out, 0, sizeof(float) * outlen);
@@ -1499,10 +1499,10 @@ pdf_evalfunction(pdf_function *func, float *in, int inlen, float *out, int outle
switch(func->type)
{
- case SAMPLE: evalsamplefunc(func, in, out); break;
- case EXPONENTIAL: evalexponentialfunc(func, *in, out); break;
- case STITCHING: evalstitchingfunc(func, *in, out); break;
- case POSTSCRIPT: evalpostscriptfunc(func, in, out); break;
+ case SAMPLE: eval_sample_func(func, in, out); break;
+ case EXPONENTIAL: eval_exponential_func(func, *in, out); break;
+ case STITCHING: eval_stitching_func(func, *in, out); break;
+ case POSTSCRIPT: eval_postscript_func(func, in, out); break;
}
}
@@ -1511,7 +1511,7 @@ pdf_evalfunction(pdf_function *func, float *in, int inlen, float *out, int outle
*/
static void
-pdf_debugindent(char *prefix, int level, char *suffix)
+pdf_debug_indent(char *prefix, int level, char *suffix)
{
int i;
@@ -1524,20 +1524,20 @@ pdf_debugindent(char *prefix, int level, char *suffix)
}
static void
-pdf_debugpsfunccode(psobj *funccode, psobj *code, int level)
+pdf_debug_ps_func_code(psobj *funccode, psobj *code, int level)
{
int eof, wasop;
- pdf_debugindent("", level, "{");
+ pdf_debug_indent("", level, "{");
/* Print empty blocks as { }, instead of separating braces on different lines. */
- if (code->type == PSOPERATOR && code->u.op == PSORETURN)
+ if (code->type == PS_OPERATOR && code->u.op == PS_OP_RETURN)
{
printf(" } ");
return;
}
- pdf_debugindent("\n", ++level, "");
+ pdf_debug_indent("\n", ++level, "");
eof = 0;
wasop = 0;
@@ -1545,60 +1545,60 @@ pdf_debugpsfunccode(psobj *funccode, psobj *code, int level)
{
switch (code->type)
{
- case PSINT:
+ case PS_INT:
if (wasop)
- pdf_debugindent("\n", level, "");
+ pdf_debug_indent("\n", level, "");
printf("%d ", code->u.i);
wasop = 0;
code++;
break;
- case PSREAL:
+ case PS_REAL:
if (wasop)
- pdf_debugindent("\n", level, "");
+ pdf_debug_indent("\n", level, "");
printf("%g ", code->u.f);
wasop = 0;
code++;
break;
- case PSOPERATOR:
- if (code->u.op == PSORETURN)
+ case PS_OPERATOR:
+ if (code->u.op == PS_OP_RETURN)
{
printf("\n");
eof = 1;
}
- else if (code->u.op == PSOIF)
+ else if (code->u.op == PS_OP_IF)
{
printf("\n");
- pdf_debugpsfunccode(funccode, &funccode[(code + 2)->u.block], level);
+ pdf_debug_ps_func_code(funccode, &funccode[(code + 2)->u.block], level);
- printf("%s", psopnames[code->u.op]);
+ printf("%s", ps_op_names[code->u.op]);
code = &funccode[(code + 3)->u.block];
- if (code->type != PSOPERATOR || code->u.op != PSORETURN)
- pdf_debugindent("\n", level, "");
+ if (code->type != PS_OPERATOR || code->u.op != PS_OP_RETURN)
+ pdf_debug_indent("\n", level, "");
wasop = 0;
}
- else if (code->u.op == PSOIFELSE)
+ else if (code->u.op == PS_OP_IFELSE)
{
printf("\n");
- pdf_debugpsfunccode(funccode, &funccode[(code + 2)->u.block], level);
+ pdf_debug_ps_func_code(funccode, &funccode[(code + 2)->u.block], level);
printf("\n");
- pdf_debugpsfunccode(funccode, &funccode[(code + 1)->u.block], level);
+ pdf_debug_ps_func_code(funccode, &funccode[(code + 1)->u.block], level);
- printf("%s", psopnames[code->u.op]);
+ printf("%s", ps_op_names[code->u.op]);
code = &funccode[(code + 3)->u.block];
- if (code->type != PSOPERATOR || code->u.op != PSORETURN)
- pdf_debugindent("\n", level, "");
+ if (code->type != PS_OPERATOR || code->u.op != PS_OP_RETURN)
+ pdf_debug_indent("\n", level, "");
wasop = 0;
}
else
{
- printf("%s ", psopnames[code->u.op]);
+ printf("%s ", ps_op_names[code->u.op]);
code++;
wasop = 1;
}
@@ -1606,17 +1606,17 @@ pdf_debugpsfunccode(psobj *funccode, psobj *code, int level)
}
}
- pdf_debugindent("", --level, "} ");
+ pdf_debug_indent("", --level, "} ");
}
static void
-pdf_debugfunctionimp(pdf_function *func, int level)
+pdf_debug_function_imp(pdf_function *func, int level)
{
int i;
- pdf_debugindent("", level, "function {\n");
+ pdf_debug_indent("", level, "function {\n");
- pdf_debugindent("", ++level, "");
+ pdf_debug_indent("", ++level, "");
switch (func->type)
{
case SAMPLE:
@@ -1633,17 +1633,17 @@ pdf_debugfunctionimp(pdf_function *func, int level)
break;
}
- pdf_debugindent("\n", level, "");
+ pdf_debug_indent("\n", level, "");
printf("%d input -> %d output\n", func->m, func->n);
- pdf_debugindent("", level, "domain ");
+ pdf_debug_indent("", level, "domain ");
for (i = 0; i < func->m; i++)
printf("%g %g ", func->domain[i][0], func->domain[i][1]);
printf("\n");
- if (func->hasrange)
+ if (func->has_range)
{
- pdf_debugindent("", level, "range ");
+ pdf_debug_indent("", level, "range ");
for (i = 0; i < func->n; i++)
printf("%g %g ", func->range[i][0], func->range[i][1]);
printf("\n");
@@ -1652,22 +1652,22 @@ pdf_debugfunctionimp(pdf_function *func, int level)
switch (func->type)
{
case SAMPLE:
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("bps: %d\n", func->u.sa.bps);
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("size: [ ");
for (i = 0; i < func->m; i++)
printf("%d ", func->u.sa.size[i]);
printf("]\n");
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("encode: [ ");
for (i = 0; i < func->m; i++)
printf("%g %g ", func->u.sa.encode[i][0], func->u.sa.encode[i][1]);
printf("]\n");
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("decode: [ ");
for (i = 0; i < func->m; i++)
printf("%g %g ", func->u.sa.decode[i][0], func->u.sa.decode[i][1]);
@@ -1675,16 +1675,16 @@ pdf_debugfunctionimp(pdf_function *func, int level)
break;
case EXPONENTIAL:
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("n: %g\n", func->u.e.n);
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("c0: [ ");
for (i = 0; i < func->n; i++)
printf("%g ", func->u.e.c0[i]);
printf("]\n");
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("c1: [ ");
for (i = 0; i < func->n; i++)
printf("%g ", func->u.e.c1[i]);
@@ -1692,36 +1692,36 @@ pdf_debugfunctionimp(pdf_function *func, int level)
break;
case STITCHING:
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("%d functions\n", func->u.st.k);
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("bounds: [ ");
for (i = 0; i < func->u.st.k - 1; i++)
printf("%g ", func->u.st.bounds[i]);
printf("]\n");
- pdf_debugindent("", level, "");
+ pdf_debug_indent("", level, "");
printf("encode: [ ");
for (i = 0; i < func->u.st.k * 2; i++)
printf("%g ", func->u.st.encode[i]);
printf("]\n");
for (i = 0; i < func->u.st.k; i++)
- pdf_debugfunctionimp(func->u.st.funcs[i], level);
+ pdf_debug_function_imp(func->u.st.funcs[i], level);
break;
case POSTSCRIPT:
- pdf_debugpsfunccode(func->u.p.code, func->u.p.code, level);
+ pdf_debug_ps_func_code(func->u.p.code, func->u.p.code, level);
printf("\n");
break;
}
- pdf_debugindent("", --level, "}\n");
+ pdf_debug_indent("", --level, "}\n");
}
void
-pdf_debugfunction(pdf_function *func)
+pdf_debug_function(pdf_function *func)
{
- pdf_debugfunctionimp(func, 0);
+ pdf_debug_function_imp(func, 0);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-30 12:31:30 +0000