summaryrefslogtreecommitdiff
path: root/dviware/dviimp/diext.c
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /dviware/dviimp/diext.c
Initial commit
Diffstat (limited to 'dviware/dviimp/diext.c')
-rw-r--r--dviware/dviimp/diext.c364
1 files changed, 364 insertions, 0 deletions
diff --git a/dviware/dviimp/diext.c b/dviware/dviimp/diext.c
new file mode 100644
index 0000000000..042c46975f
--- /dev/null
+++ b/dviware/dviimp/diext.c
@@ -0,0 +1,364 @@
+/*
+ External procedures for use with dviimp.
+ Written by H. Trickey, 6/25/85.
+
+ Implement the following procedures (as declared in Pascal)
+
+ function gfbyte: integer;
+ function gftwobytes: integer;
+ function gfthreebytes: integer;
+ function gfsignedquad: integer;
+ function getbyte: integer;
+ function signedbyte: integer;
+ function gettwobytes: integer;
+ function signedpair: integer;
+ function getthreebytes: integer;
+ function signedtrio: integer;
+ function signedquad: integer;
+ function curpos(var f:bytefile):integer;
+ procedure imbyte(w:integer);
+ procedure imhalfword(w:integer);
+ procedure setpos(var f:bytefile;n:integer);
+ procedure setpaths;
+ function testaccess(accessmode:integer; filepath:integer):boolean;
+ procedure setusername;
+*/
+
+#include <stdio.h>
+#include <strings.h>
+#include <pwd.h>
+#include "h00vars.h" /* pc runtime structures */
+#include "texpaths.h"
+
+extern struct iorec dvifile,gffile,imfile; /* pc file structs */
+extern int eofdvifile,eofgffile; /* need to be set true when these happens */
+extern int curloc; /* needs to be incremented when a dvi byte is read */
+extern int curgfloc; /* needs to be incremented when a gf byte is read */
+extern int imbyteno; /* needs to be incremented when an im byte is written */
+
+/* return unsigned version of next byte in gffile */
+int gfbyte()
+{
+ register int c;
+
+ if ((c = getc(gffile.fbuf))==EOF) {
+ eofgffile = -1;
+ return(0);
+ }
+ curgfloc++;
+ return(c);
+}
+
+/* return unsigned version of next two bytes in gffile */
+int gftwobytes()
+{
+ register int a,b;
+ register FILE *iop = gffile.fbuf;
+ a = getc(iop);
+ eofgffile = ((b = getc(iop))==EOF) ? -1 : 0;
+ curgfloc += 2;
+ return((a << 8) | b);
+}
+
+/* return unsigned version of next three bytes in gffile */
+int gfthreebytes()
+{
+ register int a,b,c;
+ register FILE *iop = gffile.fbuf;
+ a = getc(iop);
+ b = getc(iop);
+ eofgffile = ((c = getc(iop))==EOF) ? -1 : 0;
+ curgfloc +=3;
+ return((a << 16) | (b << 8) | c);
+}
+
+/* return signed version of next four bytes in gffile */
+int gfsignedquad()
+{
+ register int a,b,c,d;
+ register FILE *iop = gffile.fbuf;
+ a = getc(iop);
+ b = getc(iop);
+ c = getc(iop);
+ eofgffile = ((d = getc(iop))==EOF) ? -1 : 0;
+ curgfloc += 4;
+ return((a << 24) | (b << 16) | (c << 8) | d);
+}
+
+/* return unsigned version of next byte in dvifile */
+int getbyte()
+{
+ register int c;
+
+ if ((c = getc(dvifile.fbuf))==EOF) {
+ eofdvifile = -1;
+ return(0);
+ }
+ curloc++;
+ return(c);
+}
+
+/* return signed version of next byte in dvifile */
+int signedbyte()
+{ register int c;
+ if ((c = getc(dvifile.fbuf))==EOF) {
+ eofdvifile = -1;
+ return(0);
+ }
+ curloc++;
+ if (c>127) return(c-256);
+ return(c);
+}
+
+/* return unsigned value of next two bytes (high order first) */
+int gettwobytes()
+{
+ register int a,b;
+ register FILE *iop = dvifile.fbuf;
+ a = getc(iop);
+ eofdvifile = ((b = getc(iop))==EOF) ? -1 : 0;
+ curloc += 2;
+ return((a << 8) | b);
+}
+
+/* return signed value of next two bytes (high order first) */
+int signedpair()
+{
+ register int a,b;
+ register FILE *iop = dvifile.fbuf;
+ if ( (a = getc(iop)) > 127) a -= 256; /* sign extend */
+ eofdvifile = ((b = getc(iop))==EOF) ? -1 : 0;
+ curloc += 2;
+ return((a << 8) | b);
+}
+
+/* return unsigned value of next three bytes */
+int getthreebytes()
+{
+ register int a,b,c;
+ register FILE *iop = dvifile.fbuf;
+ a = getc(iop);
+ b = getc(iop);
+ eofdvifile = ((c = getc(iop))==EOF) ? -1 : 0;
+ curloc +=3;
+ return((a << 16) | (b << 8) | c);
+}
+
+/* return signed value of next three bytes */
+int signedtrio()
+{
+ register int a,b,c;
+ register FILE *iop = dvifile.fbuf;
+ if ( (a = getc(iop)) > 127) a -= 256;
+ b = getc(iop);
+ eofdvifile = ((c = getc(iop))==EOF) ? -1 : 0;
+ curloc +=3;
+ return((a << 16) | (b << 8) | c);
+}
+
+/* return value of next four bytes */
+int signedquad()
+{
+ register int a,b,c,d;
+ register FILE *iop = dvifile.fbuf;
+ a = getc(iop);
+ b = getc(iop);
+ c = getc(iop);
+ eofdvifile = ((d = getc(iop))==EOF) ? -1 : 0;
+ curloc += 4;
+ return((a << 24) | (b << 16) | (c << 8) | d);
+}
+
+/* put the low order byte of w on imfile */
+imbyte(w)
+ int w;
+{
+ putc(w, imfile.fbuf);
+ imbyteno++;
+}
+
+/* put the two low order bytes of w on imfile, high order first */
+imhalfword(w)
+ int w;
+{
+ putc(w >> 8, imfile.fbuf);
+ putc(w, imfile.fbuf);
+ imbyteno += 2;
+}
+
+/* seek to byte n of file f; maintain eof's if f is dvifile or gffile */
+setpos(f,n)
+ register struct iorec *f;
+ int n;
+{
+ if (n>=0) {
+ fseek(f->fbuf,(long) n,0);
+ if (f==&dvifile) eofdvifile = 0;
+ else if (f==&gffile) eofgffile =0;
+ }
+ else {
+ fseek(f->fbuf, (long) n, 2);
+ if (f==&dvifile) eofdvifile = -1;
+ else if (f==&gffile) eofgffile = -1;
+ }
+}
+
+/* return current byte offset in file f */
+int curpos(f)
+ struct iorec *f;
+{
+ return((int) ftell(f->fbuf));
+}
+
+char *fontpath;
+
+char *getenv();
+
+/*
+ * setpaths is called to set up the pointer fontpath
+ * as follows: if the user's environment has a value for TEXFONTS
+ * then use it; otherwise, use defaultfontpath.
+ */
+setpaths()
+{
+ register char *envpath;
+
+ if ((envpath = getenv("TEXFONTS")) != NULL)
+ fontpath = envpath;
+ else
+ fontpath = defaultfontpath;
+}
+
+#define namelength 100 /* should agree with dvitype.ch */
+extern char curname[],realnameoffile[]; /* these have size namelength */
+
+/*
+ * testaccess(amode,filepath)
+ *
+ * Test whether or not the file whose name is in the global curname
+ * can be opened for reading (if mode=READACCESS)
+ * or writing (if mode=WRITEACCESS).
+ *
+ * The filepath argument is one of the ...FILEPATH constants defined below.
+ * If the filename given in curname does not begin with '/', we try
+ * prepending all the ':'-separated areanames in the appropriate path to the
+ * filename until access can be made, if it ever can.
+ *
+ * The realnameoffile global array will contain the name that yielded an
+ * access success.
+ */
+
+#define READACCESS 4
+#define WRITEACCESS 2
+
+#define NOFILEPATH 0
+#define FONTFILEPATH 3
+
+bool
+testaccess(amode,filepath)
+ int amode,filepath;
+{
+ register bool ok;
+ register char *p;
+ char *curpathplace;
+ int f;
+
+ switch(filepath) {
+ case NOFILEPATH: curpathplace = NULL; break;
+ case FONTFILEPATH: curpathplace = fontpath; break;
+ }
+ if (curname[0]=='/') /* file name has absolute path */
+ curpathplace = NULL;
+ do {
+ packrealnameoffile(&curpathplace);
+ if (amode==READACCESS)
+ /* use system call "access" to see if we could read it */
+ if (access(realnameoffile,READACCESS)==0) ok = TRUE;
+ else ok = FALSE;
+ else {
+ /* WRITEACCESS: use creat to see if we could create it, but close
+ the file again if we're OK, to let pc open it for real */
+ f = creat(realnameoffile,0666);
+ if (f>=0) ok = TRUE;
+ else ok = FALSE;
+ if (ok)
+ close(f);
+ }
+ } while (!ok && curpathplace != NULL);
+ if (ok) { /* pad realnameoffile with blanks, as Pascal wants */
+ for (p = realnameoffile; *p != '\0'; p++)
+ /* nothing: find end of string */ ;
+ while (p < &(realnameoffile[namelength]))
+ *p++ = ' ';
+ }
+ return (ok ? -1 : 0);
+}
+
+/*
+ * packrealnameoffile(cpp) makes realnameoffile contain the directory at *cpp,
+ * followed by '/', followed by the characters in curname up until the
+ * first blank there, and finally a '\0'. The cpp pointer is left pointing
+ * at the next directory in the path.
+ * But: if *cpp == NULL, then we are supposed to use curname as is.
+ */
+packrealnameoffile(cpp)
+ char **cpp;
+{
+ register char *p,*realname;
+
+ realname = realnameoffile;
+ if ((p = *cpp)!=NULL) {
+ while ((*p != ':') && (*p != '\0')) {
+ *realname++ = *p++;
+ if (realname == &(realnameoffile[namelength-1]))
+ break;
+ }
+ if (*p == '\0') *cpp = NULL; /* at end of path now */
+ else *cpp = p+1; /* else get past ':' */
+ *realname++ = '/'; /* separate the area from the name to follow */
+ }
+ /* now append curname to realname... */
+ p = curname;
+ while (*p != ' ') {
+ if (realname >= &(realnameoffile[namelength-1])) {
+ fprintf(stderr,"! Full file name is too long\n");
+ break;
+ }
+ *realname++ = *p++;
+ }
+ *realname = '\0';
+}
+
+extern struct passwd * getpwuid();
+extern char username[];
+extern int lenusername;
+/*
+ * find out the caller's name, putting it into username[1..namelength]
+ * and put the length used into lenusername
+ */
+setusername()
+{
+ int i;
+ char *nam;
+
+ nam = getpwuid(getuid())->pw_name;
+ for (i=0; *nam!=0 && *nam!='(' && i<namelength; )
+ username[i++] = *nam++;
+ lenusername = i;
+}
+
+extern char hostname[];
+extern int lenhostname;
+sethostnam()
+{
+ int i;
+ char nam[namelength];
+
+ lenhostname = 0;
+ if (gethostname(nam,255) != 0) return;
+ for (i=0; nam[i]!=0 && nam[i]!='.' && i<namelength; ) {
+ hostname[i] = nam[i];
+ i++;
+ }
+ lenhostname = i;
+}