home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Elysian Archive
/
AmigaElysianArchive.iso
/
prog
/
c
/
post17s.lha
/
postop3.c
< prev
next >
Wrap
Text File
|
1992-03-11
|
32KB
|
1,126 lines
/* PostScript interpreter file "postop3.c" - operators (3)
* (C) Adrian Aylward 1989, 1991
* V1.7 Fix setflat values out of range
*/
# include "post.h"
/* concat */
void opconcat(void)
{ struct object *token1;
float newctm[6], matrix[6];
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagrprot) error(errinvalidaccess);
getmatrix(token1->value.vref, matrix);
multiplymatrix(newctm, matrix, gstate.ctm);
memcpy((char *) gstate.ctm, (char *) newctm, sizeof newctm);
opernest -= 1;
}
/* concatmatrix */
void opconcatmatrix(void)
{ struct object *token1, *token2, *token3;
float newctm[6], matrix[6], oldctm[6];
if (opernest < 3) error(errstackunderflow);
token3 = &operstack[opernest - 1];
token2 = token3 - 1;
token1 = token2 - 1;
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagrprot) error(errinvalidaccess);
getmatrix(token1->value.vref, matrix);
if (token2->type != typearray) error(errtypecheck);
if (token2->length != 6) error(errrangecheck);
if (token2->flags & flagrprot) error(errinvalidaccess);
getmatrix(token2->value.vref, oldctm);
if (token3->type != typearray) error(errtypecheck);
if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagwprot) error(errinvalidaccess);
multiplymatrix(newctm, matrix, oldctm);
arraysave(token3->value.vref, 6);
putmatrix(token3->value.vref, newctm);
*token1 = *token3;
opernest -= 2;
}
/* currentblackgeneration */
void opcurrentblackgeneration(void)
{ if (opernest == operstacksize) error(errstackoverflow);
operstack[opernest++] = gstate.gcr;
}
/* currentcmykcolor */
void opcurrentcmykcolor(void)
{ struct object token, *token1;
float c, m, y, k;
if (opernest + 4 > operstacksize) error(errstackoverflow);
c = 1.0 - gstate.rgbw[0];
m = 1.0 - gstate.rgbw[1];
y = 1.0 - gstate.rgbw[2];
k = 1.0 - gstate.rgbw[3];
token1 = &operstack[opernest];
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = c;
token1[0] = token;
token.value.rval = m;
token1[1] = token;
token.value.rval = y;
token1[2] = token;
token.value.rval = k;
token1[3] = token;
opernest += 4;
}
/* currentcolorscreen */
void opcurrentcolorscreen(void)
{ struct object token, *token1;
int plane, p;
if (opernest + 12 > operstacksize) error(errstackoverflow);
token.type = typereal;
token.flags = 0;
token.length = 0;
p = 0;
token1 = &operstack[opernest];
for (plane = 0; plane < 4 ; plane++)
{ token.value.rval = gstate.screenfreq[p];
token1[0] = token;
token.value.rval = gstate.screenangle[p];
token1[1] = token;
token1[2] = gstate.screenfunc[p];
token1 += 3;
if (gstate.screendepth != 1) p++;
}
opernest += 12;
}
/* currentcolortransfer */
void opcurrentcolortransfer(void)
{ int plane, p;
if (opernest + 4 > operstacksize) error(errstackoverflow);
p = (gstate.screendepth == 1) ? 0 : 3;
for (plane = 0; plane < 4 ; plane++)
{ operstack[opernest++] = gstate.transfer[p];
if (gstate.screendepth != 1) p++;
}
opernest += 4;
}
/* currentdash */
void opcurrentdash(void)
{ struct object token, *token1;
if (opernest + 2 > operstacksize) error(errstackoverflow);
token1 = &operstack[opernest];
token1[0] = gstate.dasharray;
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.dashoffset;
token1[1] = token;
opernest += 2;
}
/* currentflat */
void opcurrentflat(void)
{ struct object token;
if (opernest == operstacksize) error(errstackoverflow);
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.flatness;
operstack[opernest++] = token;
}
/* currentgray */
void opcurrentgray(void)
{ struct object token;
if (opernest == operstacksize) error(errstackoverflow);
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.gray;
operstack[opernest++] = token;
}
/* currenthsbcolor */
void opcurrenthsbcolor(void)
{ struct object token, *token1;
float hsb[3];
if (opernest + 3 > operstacksize) error(errstackoverflow);
token1 = &operstack[opernest];
gethsbcolour(hsb);
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = hsb[0];
token1[0] = token;
token.value.rval = hsb[1];
token1[1] = token;
token.value.rval = hsb[2];
token1[2] = token;
opernest += 3;
}
/* currentlinecap */
void opcurrentlinecap(void)
{ struct object token;
if (opernest == operstacksize) error(errstackoverflow);
token.type = typeint;
token.flags = 0;
token.length = 0;
token.value.ival = gstate.linecap;
operstack[opernest++] = token;
}
/* currentlinejoin */
void opcurrentlinejoin(void)
{ struct object token;
if (opernest == operstacksize) error(errstackoverflow);
token.type = typeint;
token.flags = 0;
token.length = 0;
token.value.ival = gstate.linejoin;
operstack[opernest++] = token;
}
/* currentlinewidth */
void opcurrentlinewidth(void)
{ struct object token;
if (opernest == operstacksize) error(errstackoverflow);
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.linewidth;
operstack[opernest++] = token;
}
/* currentmatrix */
void opcurrentmatrix(void)
{ struct object *token1;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagwprot) error(errinvalidaccess);
arraysave(token1->value.vref, 6);
putmatrix(token1->value.vref, gstate.ctm);
}
/* currentmiterlimit */
void opcurrentmiterlimit(void)
{ struct object token;
if (opernest == operstacksize) error(errstackoverflow);
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.mitrelimit;
operstack[opernest++] = token;
}
/* currentrgbcolor */
void opcurrentrgbcolor(void)
{ struct object token, *token1;
if (opernest + 3 > operstacksize) error(errstackoverflow);
token1 = &operstack[opernest];
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.rgb[0];
token1[0] = token;
token.value.rval = gstate.rgb[1];
token1[1] = token;
token.value.rval = gstate.rgb[2];
token1[2] = token;
opernest += 3;
}
/* currentscreen */
void opcurrentscreen(void)
{ struct object token, *token1;
if (opernest + 3 > operstacksize) error(errstackoverflow);
token1 = &operstack[opernest];
token.type = typereal;
token.flags = 0;
token.length = 0;
token.value.rval = gstate.screenfreq[gstate.screendepth - 1];
token1[0] = token;
token.value.rval = gstate.screenangle[gstate.screendepth - 1];
token1[1] = token;
token1[2] = gstate.screenfunc[gstate.screendepth - 1];
opernest += 3;
}
/* currenttansfer */
void opcurrenttransfer(void)
{ if (opernest == operstacksize) error(errstackoverflow);
operstack[opernest++] = gstate.transfer[gstate.transdepth - 1];
}
/* currentundercolorremoval */
void opcurrentundercolorremoval(void)
{ if (opernest == operstacksize) error(errstackoverflow);
operstack[opernest++] = gstate.ucr;
}
/* defaultmatrix */
void opdefaultmatrix(void)
{ struct object *token1;
float newctm[6];
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagwprot) error(errinvalidaccess);
initctm(newctm);
arraysave(token1->value.vref, 6);
putmatrix(token1->value.vref, newctm);
}
/* dtransform */
void opdtransform(void)
{ struct object *token1, *token2, *token3;
struct point point;
float newctm[6];
if (opernest < 2) error(errstackunderflow);
token3 = &operstack[opernest - 1];
if (token3->type == typearray)
{ if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagrprot) error(errinvalidaccess);
if (opernest < 3) error(errstackunderflow);
token2 = token3 - 1;
token1 = token2 - 1;
getmatrix(token3->value.vref, newctm);
}
else
{ token2 = token3;
token1 = token2 - 1;
}
if (token1->type == typeint)
point.x = token1->value.ival;
else if (token1->type == typereal)
point.x = token1->value.rval;
else
error(errtypecheck);
if (token2->type == typeint)
point.y = token2->value.ival;
else if (token2->type == typereal)
point.y = token2->value.rval;
else
error(errtypecheck);
if (token3->type == typearray)
{ dtransform(&point, newctm);
opernest--;
}
else
dtransform(&point, gstate.ctm);
token1->type = typereal;
token1->value.rval = point.x;
token2->type = typereal;
token2->value.rval = point.y;
}
/* grestore */
void opgrestore(void)
{ grest();
}
/* grestoreall */
void opgrestoreall(void)
{ grestall();
}
/* gsave */
void opgsave(void)
{ gsave();
}
/* identmatrix */
void opidentmatrix(void)
{ struct object *token1;
float matrix[6];
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagwprot) error(errinvalidaccess);
matrix[0] = matrix[3] = 1.0;
matrix[1] = matrix[2] = matrix[4] = matrix[5] = 0.0;
arraysave(token1->value.vref, 6);
putmatrix(token1->value.vref, matrix);
}
/* idtransform */
void opidtransform(void)
{ struct object *token1, *token2, *token3;
struct point point;
float newctm[6];
if (opernest < 2) error(errstackunderflow);
token3 = &operstack[opernest - 1];
if (token3->type == typearray)
{ if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagrprot) error(errinvalidaccess);
if (opernest < 3) error(errstackunderflow);
token2 = token3 - 1;
token1 = token2 - 1;
getmatrix(token3->value.vref, newctm);
}
else
{ token2 = token3;
token1 = token2 - 1;
}
if (token1->type == typeint)
point.x = token1->value.ival;
else if (token1->type == typereal)
point.x = token1->value.rval;
else
error(errtypecheck);
if (token2->type == typeint)
point.y = token2->value.ival;
else if (token2->type == typereal)
point.y = token2->value.rval;
else
error(errtypecheck);
if (token3->type == typearray)
{ idtransform(&point, newctm);
opernest--;
}
else
idtransform(&point, gstate.ctm);
token1->type = typereal;
token1->value.rval = point.x;
token2->type = typereal;
token2->value.rval = point.y;
}
/* initgraphics */
void opinitgraphics(void)
{ initgraphics();
}
/* initmatrix */
void opinitmatrix(void)
{ initctm(gstate.ctm);
}
/* invertmatrix */
void opinvertmatrix(void)
{ struct object *token1, *token2;
float newctm[6], oldctm[6];
if (opernest < 2) error(errstackunderflow);
token2 = &operstack[opernest - 1];
token1 = token2 - 1;
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagrprot) error(errinvalidaccess);
if (token2->type != typearray) error(errtypecheck);
if (token2->length != 6) error(errrangecheck);
if (token2->flags & flagwprot) error(errinvalidaccess);
getmatrix(token1->value.vref, oldctm);
invertmatrix(newctm, oldctm);
arraysave(token2->value.vref, 6);
putmatrix(token2->value.vref, newctm);
*token1 = *token2;
opernest--;
}
/* itransform */
void opitransform(void)
{ struct object *token1, *token2, *token3;
struct point point;
float newctm[6];
if (opernest < 2) error(errstackunderflow);
token3 = &operstack[opernest - 1];
if (token3->type == typearray)
{ if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagrprot) error(errinvalidaccess);
if (opernest < 3) error(errstackunderflow);
token2 = token3 - 1;
token1 = token2 - 1;
getmatrix(token3->value.vref, newctm);
}
else
{ token2 = token3;
token1 = token2 - 1;
}
if (token1->type == typeint)
point.x = token1->value.ival;
else if (token1->type == typereal)
point.x = token1->value.rval;
else
error(errtypecheck);
if (token2->type == typeint)
point.y = token2->value.ival;
else if (token2->type == typereal)
point.y = token2->value.rval;
else
error(errtypecheck);
if (token3->type == typearray)
{ itransform(&point, newctm);
opernest--;
}
else
itransform(&point, gstate.ctm);
token1->type = typereal;
token1->value.rval = point.x;
token2->type = typereal;
token2->value.rval = point.y;
}
/* matrix */
void opmatrix(void)
{ struct object token;
float matrix[6];
if (opernest == operstacksize) error(errstackoverflow);
token.type = typearray;
token.flags = 0;
token.length = 6;
token.value.vref = arrayalloc(6);
matrix[0] = matrix[3] = 1.0;
matrix[1] = matrix[2] = matrix[4] = matrix[5] = 0.0;
putmatrix(token.value.vref, matrix);
operstack[opernest++] = token;
}
/* rotate */
void oprotate(void)
{ struct object *token1, *token2;
float newctm[6], matrix[6], a, s, c;
if (opernest < 1) error(errstackunderflow);
token2 = &operstack[opernest - 1];
if (token2->type == typearray)
{ if (token2->length != 6) error(errrangecheck);
if (token2->flags & flagwprot) error(errinvalidaccess);
if (opernest < 2) error(errstackunderflow);
token1 = token2 - 1;
}
else
token1 = token2;
if (token1->type == typeint)
a = token1->value.ival;
else if (token1->type == typereal)
a = token1->value.rval;
else
error(errtypecheck);
a *= degtorad;
s = sin(a);
c = cos(a);
matrix[0] = c;
matrix[1] = s;
matrix[2] = -s;
matrix[3] = c;
matrix[4] = matrix[5] = 0;
if (token2->type == typearray)
{ arraysave(token2->value.vref, 6);
putmatrix(token2->value.vref, matrix);
*token1 = *token2;
}
else
{ multiplymatrix(newctm, matrix, gstate.ctm);
memcpy((char *) gstate.ctm, (char *) newctm, sizeof newctm);
}
opernest -= 1;
}
/* scale */
void opscale(void)
{ struct object *token1, *token2, *token3;
float newctm[6], matrix[6], x, y;
if (opernest < 2) error(errstackunderflow);
token3 = &operstack[opernest - 1];
if (token3->type == typearray)
{ if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagrprot) error(errinvalidaccess);
if (opernest < 3) error(errstackunderflow);
token2 = token3 - 1;
token1 = token2 - 1;
}
else
{ token2 = token3;
token1 = token2 - 1;
}
if (token1->type == typeint)
x = token1->value.ival;
else if (token1->type == typereal)
x = token1->value.rval;
else
error(errtypecheck);
if (token2->type == typeint)
y = token2->value.ival;
else if (token2->type == typereal)
y = token2->value.rval;
else
error(errtypecheck);
matrix[0] = x;
matrix[1] = 0.0;
matrix[2] = 0.0;
matrix[3] = y;
matrix[4] = matrix[5] = 0.0;
if (token3->type == typearray)
{ arraysave(token3->value.vref, 6);
putmatrix(token3->value.vref, matrix);
*token1 = *token3;
}
else
{ multiplymatrix(newctm, matrix, gstate.ctm);
memcpy((char *) gstate.ctm, (char *) newctm, sizeof newctm);
}
opernest -= 2;
}
/* setblackgeneration */
void opsetblackgeneration(void)
{ struct object *token1;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if ((token1->type != typearray && token1->type != typepacked) ||
!(token1->flags & flagexec))
error(errtypecheck);
gstate.gcr = *token1;
opernest--;
}
/* setcmykcolor */
void opsetcmykcolor(void)
{ struct object *token1;
float cmyk[4];
int i;
if (gstate.cacheflag) error(errundefined);
if (opernest < 4) error(errstackunderflow);
token1 = &operstack[opernest - 4];
for (i = 0; i < 4; i++)
{ if (token1->type == typeint)
cmyk[i] = token1->value.ival;
else if (token1->type == typereal)
cmyk[i] = token1->value.rval;
else
error(errtypecheck);
token1++;
}
setcolour(4, cmyk);
opernest -= 4;
}
/* setcolorscreen */
void opsetcolorscreen(void)
{ struct object *token1, *token2, *token3;
struct object func[4];
float freq[4], ang[4];
int plane;
if (opernest < 12) error(errstackunderflow);
token3 = &operstack[opernest - 10];
token2 = token3 - 1;
token1 = token2 - 1;
for (plane = 0; plane < 4; plane++)
{ if (token1->type == typeint)
freq[plane] = token1->value.ival;
else if (token1->type == typereal)
freq[plane] = token1->value.rval;
else
error(errtypecheck);
if (freq[plane] <= 0.0) error(errrangecheck);
if (token2->type == typeint)
ang[plane] = token2->value.ival;
else if (token2->type == typereal)
ang[plane] = token2->value.rval;
else
error(errtypecheck);
if ((token3->type != typearray && token3->type != typepacked) ||
!(token3->flags & flagexec))
error(errtypecheck);
func[plane] = *token3;
token1 += 3;
token2 += 3;
token3 += 3;
}
gstate.screendepth = 4;
memcpy((char *) gstate.screenfreq, freq, sizeof freq);
memcpy((char *) gstate.screenangle, ang, sizeof ang);
memcpy((char *) gstate.screenfunc, func, sizeof func);
halfok = gstacksize + 1;
setuphalf();
opernest -= 12;
}
/* setcolortransfer */
void opsetcolortransfer(void)
{ struct object *token1;
struct object func[4];
int plane;
if (gstate.cacheflag) error(errundefined);
if (opernest < 4) error(errstackunderflow);
token1 = &operstack[opernest - 4];
for (plane = 0; plane < 4; plane++)
{ if ((token1->type != typearray && token1->type != typepacked) ||
!(token1->flags & flagexec))
error(errtypecheck);
func[plane] = *token1;
token1++;
}
gstate.transdepth = 4;
memcpy((char *) gstate.transfer, func, sizeof func);
gstate.shadeok = 0;
setupshade();
opernest -= 4;
}
/* setdash */
void opsetdash(void)
{ struct object *token1, *token2, *aptr;
float dashlength[dashsize], dashtotal;
float r;
int len;
if (opernest < 2) error(errstackunderflow);
token2 = &operstack[opernest - 1];
token1 = token2 - 1;
if (token1->type != typearray) error(errtypecheck);
if (token1->flags & flagrprot) error(errinvalidaccess);
if (token2->type == typeint)
r = token2->value.ival;
else if (token2->type == typereal)
r = token2->value.rval;
else
error(errtypecheck);
if (r < 0.0) error(errrangecheck);
if (token1->length != 0)
{ dashtotal = 0.0;
aptr = vmaptr(token1->value.vref);
for (len = 0; len < token1->length; len++)
{ if (aptr->type == typeint)
dashlength[len] = aptr->value.ival;
else if (aptr->type == typereal)
dashlength[len] = aptr->value.rval;
else
error(errtypecheck);
if (dashlength[len] < 0.0) error(errrangecheck);
dashtotal += dashlength[len];
aptr++;
}
if (dashtotal == 0.0) error(errrangecheck);
memcpy((char *) gstate.dashlength, (char *) dashlength,
len * sizeof (float));
}
gstate.dasharray = *token1;
gstate.dashoffset = r;
opernest -= 2;
}
/* setflat */
void opsetflat(void)
{ struct object *token1;
float r;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type == typeint)
r = token1->value.ival;
else if (token1->type == typereal)
r = token1->value.rval;
else
error(errtypecheck);
if (r < 0.2)
r = 0.2;
else if (r > 100.0)
r = 100.0;
gstate.flatness = r;
opernest--;
}
/* setgray */
void opsetgray(void)
{ struct object *token1;
float gray;
if (gstate.cacheflag) error(errundefined);
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type == typeint)
gray = token1->value.ival;
else if (token1->type == typereal)
gray = token1->value.rval;
else
error(errtypecheck);
setcolour(1, &gray);
opernest--;
}
/* sethsbcolor */
void opsethsbcolor(void)
{ struct object *token1;
float hsb[3];
int i;
if (gstate.cacheflag) error(errundefined);
if (opernest < 3) error(errstackunderflow);
token1 = &operstack[opernest - 3];
for (i = 0; i < 3; i++)
{ if (token1->type == typeint)
hsb[i] = token1->value.ival;
else if (token1->type == typereal)
hsb[i] = token1->value.rval;
else
error(errtypecheck);
token1++;
}
sethsbcolour(hsb);
opernest -= 3;
}
/* setlinecap */
void opsetlinecap(void)
{ struct object *token1;
int i;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typeint) error(errtypecheck);
i = token1->value.ival;
if (i < 0 || i > 2) error(errrangecheck);
gstate.linecap = i;
opernest--;
}
/* setlinejoin */
void opsetlinejoin(void)
{ struct object *token1;
int i;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typeint) error(errtypecheck);
i = token1->value.ival;
if (i < 0 || i > 2) error(errrangecheck);
gstate.linejoin = i;
opernest--;
}
/* setlinewidth */
void opsetlinewidth(void)
{ struct object *token1;
float r;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type == typeint)
r = token1->value.ival;
else if (token1->type == typereal)
r = token1->value.rval;
else
error(errtypecheck);
if (r < 0.0) error(errrangecheck);
gstate.linewidth = r;
opernest--;
}
/* setmatrix */
void opsetmatrix(void)
{ struct object *token1;
float newctm[6];
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type != typearray) error(errtypecheck);
if (token1->length != 6) error(errrangecheck);
if (token1->flags & flagrprot) error(errinvalidaccess);
getmatrix(token1->value.vref, newctm);
memcpy((char *) gstate.ctm, (char *) newctm, sizeof newctm);
opernest--;
}
/* setmiterlimit */
void opsetmiterlimit(void)
{ struct object *token1;
float r, s;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if (token1->type == typeint)
r = token1->value.ival;
else if (token1->type == typereal)
r = token1->value.rval;
else
error(errtypecheck);
if (r < 1.0) error(errrangecheck);
s = 1.0 / r;
gstate.mitrelimit = r;
gstate.mitresin = 2.0 * s * sqrt(1.0 - s * s);
opernest--;
}
/* setrgbcolor */
void opsetrgbcolor(void)
{ struct object *token1;
float rgb[3];
int i;
if (gstate.cacheflag) error(errundefined);
if (opernest < 3) error(errstackunderflow);
token1 = &operstack[opernest - 3];
for (i = 0; i < 3; i++)
{ if (token1->type == typeint)
rgb[i] = token1->value.ival;
else if (token1->type == typereal)
rgb[i] = token1->value.rval;
else
error(errtypecheck);
token1++;
}
setcolour(3, rgb);
opernest -= 3;
}
/* setscreen */
void opsetscreen(void)
{ struct object *token1, *token2, *token3;
float freq, ang;
if (opernest < 3) error(errstackunderflow);
token3 = &operstack[opernest - 1];
token2 = token3 - 1;
token1 = token2 - 1;
if (token1->type == typeint)
freq = token1->value.ival;
else if (token1->type == typereal)
freq = token1->value.rval;
else
error(errtypecheck);
if (freq <= 0) error(errrangecheck);
if (token2->type == typeint)
ang = token2->value.ival;
else if (token2->type == typereal)
ang = token2->value.rval;
else
error(errtypecheck);
if ((token3->type != typearray && token3->type != typepacked) ||
!(token3->flags & flagexec))
error(errtypecheck);
gstate.screendepth = 1;
gstate.screenfreq[0] = freq;
gstate.screenangle[0] = ang;
gstate.screenfunc[0] = *token3;
halfok = gstacksize + 1;
setuphalf();
opernest -= 3;
}
/* settransfer */
void opsettransfer(void)
{ struct object *token1;
if (gstate.cacheflag) error(errundefined);
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if ((token1->type != typearray && token1->type != typepacked) ||
!(token1->flags & flagexec))
error(errtypecheck);
gstate.transdepth = 1;
gstate.transfer[0] = *token1;
gstate.shadeok = 0;
setupshade();
opernest--;
}
/* setundercolorremoval */
void opsetundercolorremoval(void)
{ struct object *token1;
if (opernest < 1) error(errstackunderflow);
token1 = &operstack[opernest - 1];
if ((token1->type != typearray && token1->type != typepacked) ||
!(token1->flags & flagexec))
error(errtypecheck);
gstate.ucr = *token1;
opernest--;
}
/* transform */
void optransform(void)
{ struct object *token1, *token2, *token3;
struct point point;
float newctm[6];
if (opernest < 2) error(errstackunderflow);
token3 = &operstack[opernest - 1];
if (token3->type == typearray)
{ if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagrprot) error(errinvalidaccess);
if (opernest < 3) error(errstackunderflow);
token2 = token3 - 1;
token1 = token2 - 1;
getmatrix(token3->value.vref, newctm);
}
else
{ token2 = token3;
token1 = token2 - 1;
}
if (token1->type == typeint)
point.x = token1->value.ival;
else if (token1->type == typereal)
point.x = token1->value.rval;
else
error(errtypecheck);
if (token2->type == typeint)
point.y = token2->value.ival;
else if (token2->type == typereal)
point.y = token2->value.rval;
else
error(errtypecheck);
if (token3->type == typearray)
{ transform(&point, newctm);
opernest--;
}
else
transform(&point, gstate.ctm);
token1->type = typereal;
token1->value.rval = point.x;
token2->type = typereal;
token2->value.rval = point.y;
}
/* translate */
void optranslate(void)
{ struct object *token1, *token2, *token3;
float newctm[6], matrix[6], x, y;
if (opernest < 2) error(errstackunderflow);
token3 = &operstack[opernest - 1];
if (token3->type == typearray)
{ if (token3->length != 6) error(errrangecheck);
if (token3->flags & flagwprot) error(errinvalidaccess);
if (opernest < 3) error(errstackunderflow);
token2 = token3 - 1;
token1 = token2 - 1;
}
else
{ token2 = token3;
token1 = token2 - 1;
}
if (token1->type == typeint)
x = token1->value.ival;
else if (token1->type == typereal)
x = token1->value.rval;
else
error(errtypecheck);
if (token2->type == typeint)
y = token2->value.ival;
else if (token2->type == typereal)
y = token2->value.rval;
else
error(errtypecheck);
matrix[0] = matrix[3] = 1.0;
matrix[1] = matrix[2] = 0.0;
matrix[4] = x;
matrix[5] = y;
if (token3->type == typearray)
{ arraysave(token3->value.vref, 6);
putmatrix(token3->value.vref, matrix);
*token1 = *token3;
}
else
{ multiplymatrix(newctm, matrix, gstate.ctm);
memcpy((char *) gstate.ctm, (char *) newctm, sizeof newctm);
}
opernest -= 2;
}
/* Initialise the operators (3) */
void initop3(void)
{ systemop(opconcat, "concat");
systemop(opconcatmatrix, "concatmatrix");
systemop(opcurrentblackgeneration,"currentblackgeneration");
systemop(opcurrentcmykcolor, "currentcmykcolor");
systemop(opcurrentcolorscreen,"currentcolorscreen");
systemop(opcurrentcolortransfer,"currentcolortransfer");
systemop(opcurrentdash, "currentdash");
systemop(opcurrentflat, "currentflat");
systemop(opcurrentgray, "currentgray");
systemop(opcurrenthsbcolor, "currenthsbcolor");
systemop(opcurrentlinecap, "currentlinecap");
systemop(opcurrentlinejoin, "currentlinejoin");
systemop(opcurrentlinewidth, "currentlinewidth");
systemop(opcurrentmatrix, "currentmatrix");
systemop(opcurrentmiterlimit,"currentmiterlimit");
systemop(opcurrentrgbcolor, "currentrgbcolor");
systemop(opcurrentscreen, "currentscreen");
systemop(opcurrenttransfer, "currenttransfer");
systemop(opcurrentundercolorremoval,"currentundercolorremoval");
systemop(opdefaultmatrix, "defaultmatrix");
systemop(opdtransform, "dtransform");
systemop(opgrestore, "grestore");
systemop(opgrestoreall, "grestoreall");
systemop(opgsave, "gsave");
systemop(opidentmatrix, "identmatrix");
systemop(opidtransform, "idtransform");
systemop(opinitgraphics, "initgraphics");
systemop(opinitmatrix, "initmatrix");
systemop(opinvertmatrix, "invertmatrix");
systemop(opitransform, "itransform");
systemop(opmatrix, "matrix");
systemop(oprotate, "rotate");
systemop(opscale, "scale");
systemop(opsetblackgeneration,"setblackgeneration");
systemop(opsetcmykcolor, "setcmykcolor");
systemop(opsetcolorscreen, "setcolorscreen");
systemop(opsetcolortransfer, "setcolortransfer");
systemop(opsetdash, "setdash");
systemop(opsetflat, "setflat");
systemop(opsetgray, "setgray");
systemop(opsethsbcolor, "sethsbcolor");
systemop(opsetlinecap, "setlinecap");
systemop(opsetlinejoin, "setlinejoin");
systemop(opsetlinewidth, "setlinewidth");
systemop(opsetmatrix, "setmatrix");
systemop(opsetmiterlimit, "setmiterlimit");
systemop(opsetrgbcolor, "setrgbcolor");
systemop(opsetscreen, "setscreen");
systemop(opsettransfer, "settransfer");
systemop(opsetundercolorremoval,"setundercolorremoval");
systemop(optransform, "transform");
systemop(optranslate, "translate");
}
/* End of file "postop3.c" */