shithub: pdffs

Download patch

ref: 9d76340ea8eda416be520c79c176c69019e3e519
parent: daf3484d2e3b88b6273bbfc4d8fd2a8ad95d8da8
author: Sigrid Solveig Haflínudóttir <ftrvxmtrx@gmail.com>
date: Mon May 31 19:59:33 EDT 2021 

commit latest op.c changes


--- a/op.c
+++ b/op.c
@@ -14,666 +14,690 @@
 
 struct Op {
 	char *s;
-	int (*f)(Op *op, Object *argv);
+	int (*f)(Op *op, Object *s);
 	int argc;
 	int flags;
 };
 
 static int
-cobegin(Op *op, Object *argv)
+cobegin(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-coend(Op *op, Object *argv)
+coend(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gspush(Op *op, Object *argv)
+gspush(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gspop(Op *op, Object *argv)
+gspop(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsctm(Op *op, Object *argv)
+gsctm(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gswidth(Op *op, Object *argv)
+gswidth(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gscap(Op *op, Object *argv)
+gscap(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsjoin(Op *op, Object *argv)
+gsjoin(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsmiterlim(Op *op, Object *argv)
+gsmiterlim(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsdash(Op *op, Object *argv)
+gsdash(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsintent(Op *op, Object *argv)
+gsintent(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsflatness(Op *op, Object *argv)
+gsflatness(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-gsstate(Op *op, Object *argv)
+gsstate(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-pcmove(Op *op, Object *argv)
+pcmove(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-pcline(Op *op, Object *argv)
+pcline(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-pccurve(Op *op, Object *argv)
+pccurve(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-pcsubpath(Op *op, Object *argv)
+pcsubpath(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-pcrect(Op *op, Object *argv)
+pcrect(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ppstroke(Op *op, Object *argv)
+ppstroke(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ppstrokec(Op *op, Object *argv)
+ppstrokec(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ppfill(Op *op, Object *argv)
+ppfill(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ppfills(Op *op, Object *argv)
+ppfills(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ppfillcfs(Op *op, Object *argv)
+ppfillcfs(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ppc(Op *op, Object *argv)
+ppc(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-cpclip(Op *op, Object *argv)
+cpclip(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-cspace(Op *op, Object *argv)
+cspace(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ccolour(Op *op, Object *argv)
+ccolour(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ccolour2(Op *op, Object *argv)
+ccolour2(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-cgray(Op *op, Object *argv)
+cgray(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-crgb(Op *op, Object *argv)
+crgb(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-ccmyk(Op *op, Object *argv)
+ccmyk(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-sshade(Op *op, Object *argv)
+sshade(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-eoobject(Op *op, Object *argv)
+eoobject(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-iibegin(Op *op, Object *argv)
+iibegin(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-iidata(Op *op, Object *argv)
+iidata(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-iiend(Op *op, Object *argv)
+iiend(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tsspace(Op *op, Object *argv)
+tsspace(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tswspace(Op *op, Object *argv)
+tswspace(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tshscale(Op *op, Object *argv)
+tshscale(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tslead(Op *op, Object *argv)
+tslead(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tsfontsz(Op *op, Object *argv)
+tsfontsz(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tsrendmode(Op *op, Object *argv)
+tsrendmode(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tsrise(Op *op, Object *argv)
+tsrise(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tobegin(Op *op, Object *argv)
+tobegin(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-toend(Op *op, Object *argv)
+toend(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tpmove(Op *op, Object *argv)
+tpmove(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tpmatrix(Op *op, Object *argv)
+tpmatrix(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-tpmove0(Op *op, Object *argv)
+tpmove0(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-thshow(Op *op, Object *argv)
+thshow(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-thshowarr(Op *op, Object *argv)
+thshowarr(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t3width(Op *op, Object *argv)
+t3width(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t3widthbb(Op *op, Object *argv)
+t3widthbb(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4add(Op *op, Object *argv)
+t4add(Op *, Object *s)
 {
-	USED(op, argv);
+	double x;
+
+	x = objat(s+1, Onum)->num.d + objat(s+0, Onum)->num.d;
+	s = pop(s);
+	s->num.d = x;
+	s->num.i = x;
+
 	return 0;
 }
 
 static int
-t4sub(Op *op, Object *argv)
+t4sub(Op *op, Object *s)
 {
-	USED(op, argv);
+	double x;
+
+	x = objat(s+1, Onum)->num.d - objat(s+0, Onum)->num.d;
+	s = pop(s);
+	s->num.d = x;
+	s->num.i = x;
+
 	return 0;
 }
 
 static int
-t4mul(Op *op, Object *argv)
+t4mul(Op *op, Object *s)
 {
-	USED(op, argv);
+	double x;
+
+	x = objat(s+1, Onum)->num.d * objat(s+0, Onum)->num.d;
+	s = pop(s);
+	s->num.d = x;
+	s->num.i = x;
+
 	return 0;
 }
 
 static int
-t4div(Op *op, Object *argv)
+t4div(Op *op, Object *s)
 {
-	USED(op, argv);
+	double x;
+
+	x = objat(s+1, Onum)->num.d / objat(s+0, Onum)->num.d;
+	s = pop(s);
+	s->num.d = x;
+	s->num.i = x;
+
 	return 0;
 }
 
 static int
-t4idiv(Op *op, Object *argv)
+t4idiv(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4mod(Op *op, Object *argv)
+t4mod(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4neg(Op *op, Object *argv)
+t4neg(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4abs(Op *op, Object *argv)
+t4abs(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4ceiling(Op *op, Object *argv)
+t4ceiling(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4floor(Op *op, Object *argv)
+t4floor(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4round(Op *op, Object *argv)
+t4round(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4truncate(Op *op, Object *argv)
+t4truncate(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4sqrt(Op *op, Object *argv)
+t4sqrt(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4sin(Op *op, Object *argv)
+t4sin(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4cos(Op *op, Object *argv)
+t4cos(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4atan(Op *op, Object *argv)
+t4atan(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4exp(Op *op, Object *argv)
+t4exp(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4ln(Op *op, Object *argv)
+t4ln(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4log(Op *op, Object *argv)
+t4log(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4cvi(Op *op, Object *argv)
+t4cvi(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4cvr(Op *op, Object *argv)
+t4cvr(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4eq(Op *op, Object *argv)
+t4eq(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4ne(Op *op, Object *argv)
+t4ne(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4gt(Op *op, Object *argv)
+t4gt(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4ge(Op *op, Object *argv)
+t4ge(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4lt(Op *op, Object *argv)
+t4lt(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4le(Op *op, Object *argv)
+t4le(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4and(Op *op, Object *argv)
+t4and(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4or(Op *op, Object *argv)
+t4or(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4xor(Op *op, Object *argv)
+t4xor(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4not(Op *op, Object *argv)
+t4not(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4bitshift(Op *op, Object *argv)
+t4bitshift(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4true(Op *op, Object *argv)
+t4true(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4false(Op *op, Object *argv)
+t4false(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4if(Op *op, Object *argv)
+t4if(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4ifelse(Op *op, Object *argv)
+t4ifelse(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4pop(Op *op, Object *argv)
+t4pop(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4exch(Op *op, Object *argv)
+t4exch(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4dup(Op *op, Object *argv)
+t4dup(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4copy(Op *op, Object *argv)
+t4copy(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4index(Op *op, Object *argv)
+t4index(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }
 
 static int
-t4roll(Op *op, Object *argv)
+t4roll(Op *op, Object *s)
 {
-	USED(op, argv);
+	USED(op, s);
 	return 0;
 }