diff options
Diffstat (limited to 'dviware/dviimp/diext.c')
-rw-r--r-- | dviware/dviimp/diext.c | 364 |
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; +} |