These do little to nothing on modern compilers.
void vcopy(const float *v1, float *v2)
{
- register int i;
+ int i;
for (i = 0; i < 3; i++)
v2[i] = v1[i];
}
#include "ast.h"
-int chresc(register const char *s, char **p)
+int chresc(const char *s, char **p)
{
- register const char *q;
- register int c;
+ const char *q;
+ int c;
switch (c = *s++) {
case 0:
#include "ast.h"
-int chrtoi(register const char *s)
+int chrtoi(const char *s)
{
- register int c;
- register int n;
- register int x;
+ int c;
+ int n;
+ int x;
char *p;
c = 0;
char *fmtbuf(size_t n)
{
- register char *cur;
+ char *cur;
if (n > (&buf[elementsof(buf)] - nxt))
nxt = buf;
char *fmtquote(const char *as, const char *qb, const char *qe, size_t n,
int flags)
{
- register const unsigned char *s = (const unsigned char *) as;
- register const unsigned char *e = s + n;
- register char *b;
- register int c;
- register int escaped;
- register int spaced;
+ const unsigned char *s = (const unsigned char *) as;
+ const unsigned char *e = s + n;
+ char *b;
+ int c;
+ int escaped;
+ int spaced;
int shell;
char *f;
char *buf;
char *pathcanon(char *path, int flags);
-char *pathaccess(register char *path, register const char *dirs,
- const char *a, const char *b, register int mode)
+char *pathaccess(char *path, const char *dirs,
+ const char *a, const char *b, int mode)
{
- register int m = 0;
+ int m = 0;
int sep = ':';
char cwd[PATH_MAX];
struct stat st;
char *pathbin(void)
{
- register char *bin;
+ char *bin;
static char *val;
char *pathcanon(char *path, int flags)
{
- register char *p;
- register char *r;
- register char *s;
- register char *t;
- register int dots;
+ char *p;
+ char *r;
+ char *s;
+ char *t;
+ int dots;
char *phys;
char *v;
char* e = path + PATH_MAX;
#include "ast.h"
-char *pathcat(char *path, register const char *dirs, int sep,
- const char *a, register const char *b)
+char *pathcat(char *path, const char *dirs, int sep,
+ const char *a, const char *b)
{
- register char *s;
+ char *s;
s = path;
while (*dirs && *dirs != sep)
int pathexists(char *path, int mode)
{
- register char *s;
- register char *e;
- register Tree_t *p;
- register Tree_t *t;
- register int c;
+ char *s;
+ char *e;
+ Tree_t *p;
+ Tree_t *t;
+ int c;
char *ee;
int cc = 0;
int x;
char *pathfind(const char *name, const char *lib, const char *type,
char *buf, size_t size)
{
- register Dir_t *dp;
- register char *s;
+ Dir_t *dp;
+ char *s;
char tmp[PATH_MAX];
if (access(name, R_OK) >= 0)
buf[n] = 0;
#ifdef UNIV_MAX
if (isspace(*buf)) {
- register char *s;
- register char *t;
- register char *u;
- register char *v;
+ char *s;
+ char *t;
+ char *u;
+ char *v;
int match = 0;
char tmp[PATH_MAX];
#endif
char **opt_info_argv;
-char *pathpath(register char *path, const char *p, const char *a, int mode)
+char *pathpath(char *path, const char *p, const char *a, int mode)
{
- register char *s;
+ char *s;
char *x;
char buf[PATH_MAX];
* copy t into s, return a pointer to the end of s ('\0')
*/
-char *strcopy(register char *s, register const char *t)
+char *strcopy(char *s, const char *t)
{
if (!t)
return (s);
#include "ast.h"
-int stresc(register char *s)
+int stresc(char *s)
{
- register char *t;
- register int c;
+ char *t;
+ int c;
char *b;
char *p;
* 0 returned if s runs out
*/
-static char *gobble(Match_t * mp, register char *s, register int sub,
+static char *gobble(Match_t * mp, char *s, int sub,
int *g, int clear)
{
- register int p = 0;
- register char *b = 0;
+ int p = 0;
+ char *b = 0;
int c = 0;
int n;
}
}
-static int grpmatch(Match_t *, int, char *, register char *, char *, int);
+static int grpmatch(Match_t *, int, char *, char *, char *, int);
#if _DEBUG_MATCH
#define RETURN(v) {error_info.indent--;return (v);}
onematch(Match_t * mp, int g, char *s, char *p, char *e, char *r,
int flags)
{
- register int pc;
- register int sc;
- register int n;
- register int icase;
+ int pc;
+ int sc;
+ int n;
+ int icase;
char *olds;
char *oldp;
*/
static int
-grpmatch(Match_t * mp, int g, char *s, register char *p, char *e,
+grpmatch(Match_t * mp, int g, char *s, char *p, char *e,
int flags)
{
- register char *a;
+ char *a;
#if _DEBUG_MATCH
error_info.indent++;
int strgrpmatch(const char *b, const char *p, int *sub, int n, int flags)
{
- register int i;
- register char *s;
+ int i;
+ char *s;
char *e;
Match_t match;
long strton(const char *a, char **e, char *basep, int m)
{
- register unsigned char *s = (unsigned char *) a;
- register long n;
- register int c;
- register int base;
- register int shift;
- register unsigned char *p;
- register unsigned char *cv;
+ unsigned char *s = (unsigned char *) a;
+ long n;
+ int c;
+ int base;
+ int shift;
+ unsigned char *p;
+ unsigned char *cv;
int negative;
if (!basep || (base = *basep) < 0 || base > 64)
**
** Written by Kiem-Phong Vo (05/25/96)
*/
-int dtclose(reg Dt_t* dt)
+int dtclose(Dt_t* dt)
{
Dtdisc_t *disc;
int ev = 0;
Dtdisc_t* dtdisc(Dt_t* dt, Dtdisc_t* disc, int type)
{
- reg Dtsearch_f searchf;
- reg Dtlink_t *r, *t;
- reg char* k;
- reg Dtdisc_t* old;
+ Dtsearch_f searchf;
+ Dtlink_t *r, *t;
+ char* k;
+ Dtdisc_t* old;
if(!(old = dt->disc) ) /* initialization call from dtopen() */
{ dt->disc = disc;
dt->data->size = 0;
if(dt->data->type&(DT_SET|DT_BAG))
- { reg Dtlink_t **s, **ends;
+ { Dtlink_t **s, **ends;
ends = (s = dt->data->htab) + dt->data->ntab;
while(s < ends)
*s++ = NIL(Dtlink_t*);
** Written by Kiem-Phong Vo (5/25/96).
*/
-Dtlink_t* dtextract(reg Dt_t* dt)
+Dtlink_t* dtextract(Dt_t* dt)
{
- reg Dtlink_t *list, **s, **ends;
+ Dtlink_t *list, **s, **ends;
if(dt->data->type&(DT_OSET|DT_OBAG) )
list = dt->data->here;
Dtlink_t* dtflatten(Dt_t* dt)
{
- reg Dtlink_t *t, *r, *list, *last, **s, **ends;
+ Dtlink_t *t, *r, *list, *last, **s, **ends;
/* already flattened */
if(dt->data->type&DT_FLATTEN )
/* resize the hash table */
static void dthtab(Dt_t* dt)
{
- reg Dtlink_t *t, *r, *p, **s, **hs, **is, **olds;
+ Dtlink_t *t, *r, *p, **s, **hs, **is, **olds;
int n, k;
if(dt->data->minp > 0 && dt->data->ntab > 0) /* fixed table size */
}
}
-static void* dthash(Dt_t* dt, reg void* obj, int type)
+static void* dthash(Dt_t* dt, void* obj, int type)
{
- reg Dtlink_t *t, *r = NULL, *p;
- reg void *k, *key;
- reg uint hsh;
- reg int lk, sz, ky;
- reg Dtcompar_f cmpf;
- reg Dtdisc_t* disc;
- reg Dtlink_t **s = NULL, **ends;
+ Dtlink_t *t, *r = NULL, *p;
+ void *k, *key;
+ uint hsh;
+ int lk, sz, ky;
+ Dtcompar_f cmpf;
+ Dtdisc_t* disc;
+ Dtlink_t **s = NULL, **ends;
UNFLATTEN(dt);
/* short-hand notations */
#define NIL(t) ((t)0)
-#define reg register
#define uint unsigned int
#define left hl._left
#define hash hl._hash
** Written by Kiem-Phong Vo (05/25/96)
*/
-static void* dtlist(reg Dt_t* dt, reg void* obj, reg int type)
+static void* dtlist(Dt_t* dt, void* obj, int type)
{
- reg int lk, sz, ky;
- reg Dtcompar_f cmpf;
- reg Dtdisc_t* disc;
- reg Dtlink_t *r, *t;
- reg void *key, *k;
+ int lk, sz, ky;
+ Dtcompar_f cmpf;
+ Dtdisc_t* disc;
+ Dtlink_t *r, *t;
+ void *key, *k;
UNFLATTEN(dt);
disc = dt->disc; _DTDSC(disc,ky,sz,lk,cmpf);
Dtmethod_t* dtmethod(Dt_t* dt, Dtmethod_t* meth)
{
- reg Dtlink_t *list, *r;
- reg Dtdisc_t* disc = dt->disc;
- reg Dtmethod_t* oldmeth = dt->meth;
+ Dtlink_t *list, *r;
+ Dtdisc_t* disc = dt->disc;
+ Dtmethod_t* oldmeth = dt->meth;
if(!meth || meth->type == oldmeth->type)
return oldmeth;
if(meth->type&(DT_LIST|DT_STACK|DT_QUEUE) )
{ if(!(oldmeth->type&(DT_LIST|DT_STACK|DT_QUEUE)) )
{ if((r = list) )
- { reg Dtlink_t* t;
+ { Dtlink_t* t;
for(t = r->right; t; r = t, t = t->right )
t->left = r;
list->left = r;
while(list)
{ r = list->right;
if(rehash)
- { reg void* key = _DTOBJ(list,disc->link);
+ { void* key = _DTOBJ(list,disc->link);
key = _DTKEY(key,disc->key,disc->size);
list->hash = _DTHSH(dt,key,disc,disc->size);
}
Dt_t* dtopen(Dtdisc_t* disc, Dtmethod_t* meth)
{
Dt_t* dt = (Dt_t*)Version; /* shut-up unuse warning */
- reg int e;
+ int e;
Dtdata_t* data;
if(!disc || !meth)
** Written by Kiem-Phong Vo (5/25/96)
*/
-void* dtrenew(Dt_t* dt, reg void* obj)
+void* dtrenew(Dt_t* dt, void* obj)
{
- reg void* key;
- reg Dtlink_t *e, *t, **s;
- reg Dtdisc_t* disc = dt->disc;
+ void* key;
+ Dtlink_t *e, *t, **s;
+ Dtdisc_t* disc = dt->disc;
UNFLATTEN(dt);
** Written by Kiem-Phong Vo (5/25/96)
*/
-int dtrestore(reg Dt_t* dt, reg Dtlink_t* list)
+int dtrestore(Dt_t* dt, Dtlink_t* list)
{
- reg Dtlink_t *t, **s, **ends;
- reg int type;
- reg Dtsearch_f searchf = dt->meth->searchf;
+ Dtlink_t *t, **s, **ends;
+ int type;
+ Dtsearch_f searchf = dt->meth->searchf;
type = dt->data->type&DT_FLATTEN;
if(!list) /* restoring a flattened dictionary */
** Written by Kiem-Phong Vo (5/25/96)
*/
-static int treecount(reg Dtlink_t* e)
+static int treecount(Dtlink_t* e)
{ return e ? treecount(e->left) + treecount(e->right) + 1 : 0;
}
int dtsize(Dt_t* dt)
{
- reg Dtlink_t* t;
- reg int size;
+ Dtlink_t* t;
+ int size;
UNFLATTEN(dt);
level[depth] += 1;
}
-static void dthstat(reg Dtdata_t* data, Dtstat_t* ds, reg int* count)
+static void dthstat(Dtdata_t* data, Dtstat_t* ds, int* count)
{
- reg Dtlink_t* t;
- reg int n, h;
+ Dtlink_t* t;
+ int n, h;
for(h = data->ntab-1; h >= 0; --h)
{ n = 0;
}
}
-int dtstat(reg Dt_t* dt, Dtstat_t* ds, int all)
+int dtstat(Dt_t* dt, Dtstat_t* ds, int all)
{
- reg int i;
+ int i;
static int *Count, Size;
UNFLATTEN(dt);
** Written by Kiem-Phong Vo (02/28/03)
*/
-uint dtstrhash(reg uint h, void* args, reg int n)
+uint dtstrhash(uint h, void* args, int n)
{
- reg unsigned char* s = (unsigned char*)args;
+ unsigned char* s = (unsigned char*)args;
if(n <= 0)
{ for(; *s != 0; s += s[1] ? 2 : 1)
n = s - (unsigned char*)args;
}
else
- { reg unsigned char* ends;
+ { unsigned char* ends;
for(ends = s+n-1; s < ends; s += 2)
h = (h + (s[0]<<8) + s[1])*DT_PRIME;
if(s <= ends)
*/
-static void* dtvsearch(Dt_t* dt, reg void* obj, reg int type)
+static void* dtvsearch(Dt_t* dt, void* obj, int type)
{
Dt_t *d, *p;
void *o, *n, *ok, *nk;
}
}
-Dt_t* dtview(reg Dt_t* dt, reg Dt_t* view)
+Dt_t* dtview(Dt_t* dt, Dt_t* view)
{
- reg Dt_t* d;
+ Dt_t* d;
UNFLATTEN(dt);
if(view)
** Written by Kiem-Phong Vo (5/25/96)
*/
-int dtwalk(reg Dt_t* dt, int (*userf)(Dt_t*, void*, void*), void* data)
+int dtwalk(Dt_t* dt, int (*userf)(Dt_t*, void*, void*), void* data)
{
- reg void *obj, *next;
- reg Dt_t* walk;
- reg int rv;
+ void *obj, *next;
+ Dt_t* walk;
+ int rv;
for(obj = dtfirst(dt); obj; )
{ if(!(walk = dt->walk) )
static int in_cross(node_t * v, node_t * w)
{
- register edge_t **e1, **e2;
- register int inv, cross = 0, t;
+ edge_t **e1, **e2;
+ int inv, cross = 0, t;
for (e2 = ND_in(w).list; *e2; e2++) {
- register int cnt = ED_xpenalty(*e2);
+ int cnt = ED_xpenalty(*e2);
inv = ND_order((agtail(*e2)));
static int out_cross(node_t * v, node_t * w)
{
- register edge_t **e1, **e2;
- register int inv, cross = 0, t;
+ edge_t **e1, **e2;
+ int inv, cross = 0, t;
for (e2 = ND_out(w).list; *e2; e2++) {
- register int cnt = ED_xpenalty(*e2);
+ int cnt = ED_xpenalty(*e2);
inv = ND_order(aghead(*e2));
for (e1 = ND_out(v).list; *e1; e1++) {
if (rp >= ep)
break;
if (muststay == FALSE) {
- register int p1 = (ND_mval(*lp));
- register int p2 = (ND_mval(*rp));
+ int p1 = (ND_mval(*lp));
+ int p2 = (ND_mval(*rp));
if ((p1 > p2) || ((p1 == p2) && (reverse))) {
exchange(*lp, *rp);
changed++;
Count[i] = 0;
for (top = 0; top < GD_rank(g)[r].n; top++) {
- register edge_t *e;
+ edge_t *e;
if (max > 0) {
for (i = 0; (e = ND_out(rtop[top]).list[i]); i++) {
for (k = ND_order(aghead(e)) + 1; k <= max; k++)
}
}
for (i = 0; (e = ND_out(rtop[top]).list[i]); i++) {
- register int inv = ND_order(aghead(e));
+ int inv = ND_order(aghead(e));
if (inv > max)
max = inv;
Count[inv] += ED_xpenalty(e);
static void
print(Excc_t* cc, Exnode_t* expr)
{
- register Print_t* x;
- register int i;
+ Print_t* x;
+ int i;
if ((x = expr->data.print.args))
{
static void
scan(Excc_t* cc, Exnode_t* expr)
{
- register Print_t* x;
- register int i;
+ Print_t* x;
+ int i;
if ((x = expr->data.print.args))
{
*/
static void
-gen(Excc_t* cc, register Exnode_t* expr)
+gen(Excc_t* cc, Exnode_t* expr)
{
- register Exnode_t* x;
- register Exnode_t* y;
- register int n;
- register int m;
- register int t;
+ Exnode_t* x;
+ Exnode_t* y;
+ int n;
+ int m;
+ int t;
char* s;
Extype_t* v;
Extype_t** p;
static int
global(Dt_t* table, void* object, void* handle)
{
- register Excc_t* cc = (Excc_t*)handle;
- register Exid_t* sym = (Exid_t*)object;
+ Excc_t* cc = (Excc_t*)handle;
+ Exid_t* sym = (Exid_t*)object;
if (sym->lex == DYNAMIC)
sfprintf(cc->ccdisc->text, "static %s %s;\n", extype(sym->type), sym->name);
Excc_t*
exccopen(Expr_t* expr, Exccdisc_t* disc)
{
- register Excc_t* cc;
+ Excc_t* cc;
char* id;
if (!(id = disc->id))
int
excc(Excc_t* cc, const char* name, Exid_t* sym, int type)
{
- register char* t;
+ char* t;
if (!cc)
return -1;
char*
excontext(Expr_t* p, char* buf, int n)
{
- register char* s;
- register char* t;
- register char* e;
+ char* s;
+ char* t;
+ char* e;
s = buf;
if (p->linep > p->line || p->linewrap)
static char*
lexname(int op, int subop)
{
- register char* b;
+ char* b;
static int n;
static char buf[TOTNAME][MAXNAME];
*
*/
static int
-evaldyn (Expr_t * ex, register Exnode_t * expr, void *env, int delete)
+evaldyn (Expr_t * ex, Exnode_t * expr, void *env, int delete)
{
Exassoc_t *b;
Extype_t v;
*/
static Extype_t
-getdyn(Expr_t* ex, register Exnode_t* expr, void* env, Exassoc_t** assoc)
+getdyn(Expr_t* ex, Exnode_t* expr, void* env, Exassoc_t** assoc)
{
Exassoc_t* b;
Extype_t v;
static int
prformat(Sfio_t* sp, void* vp, Sffmt_t* dp)
{
- register Fmt_t* fmt = (Fmt_t*)dp;
- register Exnode_t* node;
- register char* s;
- register char* txt;
+ Fmt_t* fmt = (Fmt_t*)dp;
+ Exnode_t* node;
+ char* s;
+ char* txt;
int n;
int from;
int to = 0;
*/
static int
-prints(Expr_t * ex, register Exnode_t * expr, void *env, Sfio_t * sp)
+prints(Expr_t * ex, Exnode_t * expr, void *env, Sfio_t * sp)
{
Extype_t v;
Exnode_t *args;
static int
print(Expr_t* ex, Exnode_t* expr, void* env, Sfio_t* sp)
{
- register Print_t* x;
+ Print_t* x;
Extype_t v;
Fmt_t fmt;
static int
scformat(Sfio_t* sp, void* vp, Sffmt_t* dp)
{
- register Fmt_t* fmt = (Fmt_t*)dp;
- register Exnode_t* node;
+ Fmt_t* fmt = (Fmt_t*)dp;
+ Exnode_t* node;
if (!fmt->actuals)
{
*/
static char*
-str_add(Expr_t* ex, register char* l, register char* r)
+str_add(Expr_t* ex, char* l, char* r)
{
sfprintf(ex->tmp, "%s%s", l, r);
return exstash(ex->tmp, ex->ve);
*/
static char*
-str_ior(Expr_t* ex, register char* l, register char* r)
+str_ior(Expr_t* ex, char* l, char* r)
{
- register int c;
- register char* s = l;
+ int c;
+ char* s = l;
while ((c = *s++))
if (!strchr(s, c))
*/
static char*
-str_and(Expr_t* ex, register char* l, register char* r)
+str_and(Expr_t* ex, char* l, char* r)
{
- register int c;
+ int c;
while ((c = *l++))
if (strchr(r, c) && !strchr(l, c))
*/
static char*
-str_xor(Expr_t* ex, register char* l, register char* r)
+str_xor(Expr_t* ex, char* l, char* r)
{
- register int c;
- register char* s = l;
+ int c;
+ char* s = l;
while ((c = *s++))
if (!strchr(r, c) && !strchr(s, c))
*/
static char*
-str_mod(Expr_t* ex, register char* l, register char* r)
+str_mod(Expr_t* ex, char* l, char* r)
{
- register int c;
+ int c;
while ((c = *l++))
if (!strchr(r, c) && !strchr(l, c))
*/
static char*
-str_mpy(Expr_t* ex, register char* l, register char* r)
+str_mpy(Expr_t* ex, char* l, char* r)
{
- register int lc;
- register int rc;
+ int lc;
+ int rc;
while ((lc = *l++) && (rc = *r++))
sfputc(ex->tmp, lc == rc ? lc : ' ');
* \digit is replaced with a subgroup match, if any.
*/
static void
-replace(Sfio_t * s, char *base, register char *repl, int ng, int *sub)
+replace(Sfio_t * s, char *base, char *repl, int ng, int *sub)
{
char c;
int idx, offset;
* return number of fields
*/
static Extype_t
-exsplit(Expr_t * ex, register Exnode_t * expr, void *env)
+exsplit(Expr_t * ex, Exnode_t * expr, void *env)
{
Extype_t v;
char *str;
* return number of tokens
*/
static Extype_t
-extokens(Expr_t * ex, register Exnode_t * expr, void *env)
+extokens(Expr_t * ex, Exnode_t * expr, void *env)
{
Extype_t v;
char *str;
* return string after pattern substitution
*/
static Extype_t
-exsub(Expr_t * ex, register Exnode_t * expr, void *env, int global)
+exsub(Expr_t * ex, Exnode_t * expr, void *env, int global)
{
char *str;
char *pat;
/* exsubstr:
* return substring.
*/
-static Extype_t exsubstr(Expr_t * ex, register Exnode_t * expr, void *env)
+static Extype_t exsubstr(Expr_t * ex, Exnode_t * expr, void *env)
{
Extype_t s;
Extype_t i;
static long seed;
static Extype_t
-eval(Expr_t* ex, register Exnode_t* expr, void* env)
+eval(Expr_t* ex, Exnode_t* expr, void* env)
{
- register Exnode_t* x;
- register Exnode_t* a;
- register Extype_t** t;
- register int n;
+ Exnode_t* x;
+ Exnode_t* a;
+ Extype_t** t;
+ int n;
Extype_t v;
Extype_t r = {0};
Extype_t i;
Exnode_t*
exnewnode(Expr_t* p, int op, int binary, int type, Exnode_t* left, Exnode_t* right)
{
- register Exnode_t* x;
+ Exnode_t* x;
x = ALLOCATE(p, Exnode_t);
memzero(x, sizeof(*x));
*/
void
-exfreenode(Expr_t* p, register Exnode_t* x)
+exfreenode(Expr_t* p, Exnode_t* x)
{
- register Print_t* pr;
- register Exref_t* r;
+ Print_t* pr;
+ Exref_t* r;
Print_t* pn;
Exref_t* rn;
int i;
* Cast x to type STRING
* Assume x->type != STRING
*/
-static Exnode_t *exstringOf(Expr_t * p, register Exnode_t * x) {
+static Exnode_t *exstringOf(Expr_t * p, Exnode_t * x) {
int type = x->type;
int cvt = 0;
/* exnoncast:
* Return first non-cast node.
*/
-Exnode_t *exnoncast(register Exnode_t * x) {
+Exnode_t *exnoncast(Exnode_t * x) {
while (x && (x->op >= F2I) && (x->op <= X2X))
x = x->data.operand.left;
return x;
}
Exnode_t*
-excast(Expr_t* p, register Exnode_t* x, register int type, register Exnode_t* xref, int arg)
+excast(Expr_t* p, Exnode_t* x, int type, Exnode_t* xref, int arg)
{
- register int t2t;
+ int t2t;
char* s;
char* e;
Extype_t
exconvert(Expr_t* p, Extype_t v, int from, int to, char* buf, size_t size)
{
- register int t2t;
+ int t2t;
int n;
Exnode_t tmp;
*/
static Exid_t*
-qualify(register Exref_t* ref, register Exid_t* sym)
+qualify(Exref_t* ref, Exid_t* sym)
{
- register Exid_t* x;
+ Exid_t* x;
char* s;
while (ref->next)
*/
static Exnode_t*
-call(Exref_t* ref, register Exid_t* fun, register Exnode_t* args)
+call(Exref_t* ref, Exid_t* fun, Exnode_t* args)
{
- register int t;
- register int type;
+ int t;
+ int type;
Exnode_t* x;
int num;
*/
static Print_t*
-preprint(register Exnode_t* args)
+preprint(Exnode_t* args)
{
- register Print_t* x;
- register char* s;
- register int c;
+ Print_t* x;
+ char* s;
+ int c;
int t;
int i;
int n;
int
expush(Expr_t* p, const char* name, int line, const char* sp, Sfio_t* fp)
{
- register Exinput_t* in;
- register char* s;
+ Exinput_t* in;
+ char* s;
char buf[PATH_MAX];
if (!(in = newof(0, Exinput_t, 1, 0)))
*/
int
-expop(register Expr_t* p)
+expop(Expr_t* p)
{
- register int c;
- register Exinput_t* in;
+ int c;
+ Exinput_t* in;
if (!(in = p->input) || !in->next || in->unit)
return -1;
*/
int
-excomp(register Expr_t* p, const char* name, int line, const char* sp, Sfio_t* fp)
+excomp(Expr_t* p, const char* name, int line, const char* sp, Sfio_t* fp)
{
Exid_t* v;
int eof;
*/
void
-exclose(register Expr_t* p, int all)
+exclose(Expr_t* p, int all)
{
- register int i;
- register Exinput_t* in;
+ int i;
+ Exinput_t* in;
if (p)
{
char*
exlexname(int op, int subop)
{
- register char* b;
+ char* b;
static int n;
static char buf[TOTNAME][MAXNAME];
*/
Expr_t*
-exopen(register Exdisc_t* disc)
+exopen(Exdisc_t* disc)
{
- register Expr_t* program;
- register Exid_t* sym;
+ Expr_t* program;
+ Exid_t* sym;
if (!(program = newof(0, Expr_t, 1, 0)))
return 0;
;
action : LABEL ':' {
- register Dtdisc_t* disc;
+ Dtdisc_t* disc;
if (expr.procedure)
exerror("no nested function definitions");
}
| SWITCH '(' expr {expr.declare=$3->type;} ')' '{' switch_list '}'
{
- register Switch_t* sw = expr.swstate;
+ Switch_t* sw = expr.swstate;
$$ = exnewnode(expr.program, $1->index, 1, INTEGER, $3, exnewnode(expr.program, DEFAULT, 1, 0, sw->defcase, sw->firstcase));
expr.swstate = expr.swstate->prev;
switch_list : /* empty */
{
- register Switch_t* sw;
+ Switch_t* sw;
int n;
if (expr.swstate)
switch_item : case_list statement_list
{
- register Switch_t* sw = expr.swstate;
+ Switch_t* sw = expr.swstate;
int n;
$$ = exnewnode(expr.program, CASE, 1, 0, $2, NiL);
}
| scan '(' args ')'
{
- register Exnode_t* x;
+ Exnode_t* x;
$$ = exnewnode(expr.program, $1->index, 0, $1->type, NiL, NiL);
if ($3 && $3->data.operand.left->type == INTEGER)
}
| formal_list ',' formal_item
{
- register Exnode_t* x;
- register Exnode_t* y;
+ Exnode_t* x;
+ Exnode_t* y;
$$ = $1;
for (x = $1; (y = x->data.operand.right); x = y);
initialize : assign
| '(' {
- register Dtdisc_t* disc;
+ Dtdisc_t* disc;
if (expr.procedure)
exerror("%s: nested function definitions not supported", expr.id->name);
int
exrewind(Expr_t* ex)
{
- register int n;
+ int n;
if (ex->linewrap)
{
*/
static int
-lex(register Expr_t* ex)
+lex(Expr_t* ex)
{
- register int c;
+ int c;
for (;;)
{
*/
int
-extoken_fn(register Expr_t* ex)
+extoken_fn(Expr_t* ex)
{
- register int c;
- register char* s;
- register int q;
+ int c;
+ char* s;
+ int q;
int b;
char* e;
Dt_t* v;
* Return -1 if conversion cannot be done, 0 otherwise.
* If arg is > 0, conversion unnecessary; just report possibility.
*/
-static int stringOf(Expr_t * prog, register Exnode_t * x, int arg, Exdisc_t* disc)
+static int stringOf(Expr_t * prog, Exnode_t * x, int arg, Exdisc_t* disc)
{
Agobj_t *objp;
int rv = 0;
* as this seemed to dangerous.
*/
static int
-convert(Expr_t * prog, register Exnode_t * x, int type,
- register Exid_t * xref, int arg, Exdisc_t * disc)
+convert(Expr_t * prog, Exnode_t * x, int type,
+ Exid_t * xref, int arg, Exdisc_t * disc)
{
Agobj_t *objp;
int ret = -1;
*/
static int RTreeReInsert(RTree_t * rtp, Node_t * n, struct ListNode **ee)
{
- register struct ListNode *l;
+ struct ListNode *l;
if (!(l = RTreeNewListNode()))
return -1;
*/
LeafList_t *RTreeSearch(RTree_t * rtp, Node_t * n, Rect_t * r)
{
- register int i;
+ int i;
LeafList_t *llp = 0;
assert(n);
RTreeInsert(RTree_t * rtp, Rect_t * r, void *data, Node_t ** n, int level)
{
/* RTreeInsert(RTree_t*rtp, Rect_t*r, int data, Node_t**n, int level) { */
- register int i;
- register Node_t *newroot;
+ int i;
+ Node_t *newroot;
Node_t *newnode=0;
Branch_t b;
int result = 0;
/* RTreeInsert2(RTree_t*rtp, Rect_t*r,
int data, Node_t*n, Node_t**new, int level) {
*/
- register int i=0;
+ int i=0;
Branch_t b;
Node_t *n2=0;
}
}
-static void FreeListNode(register struct ListNode *p)
+static void FreeListNode(struct ListNode *p)
{
free(p);
}
{
/* int */
/* RTreeDelete(RTree_t*rtp, Rect_t*r, int data, Node_t**nn) { */
- register int i;
- register Node_t *t;
+ int i;
+ Node_t *t;
struct ListNode *reInsertList = NULL;
- register struct ListNode *e;
+ struct ListNode *e;
assert(r && nn);
assert(*nn);
/* static int */
/* RTreeDelete2(RTree_t*rtp, Rect_t*r, int data, Node_t*n, ListNode_t**ee) */
{
- register int i;
+ int i;
assert(r && n && ee);
assert(data);
*/
Node_t *RTreeNewNode(RTree_t * rtp)
{
- register Node_t *n;
+ Node_t *n;
rtp->NodeCount++;
n = (Node_t *) malloc(sizeof(Node_t));
*/
void InitNode(Node_t * n)
{
- register int i;
+ int i;
n->count = 0;
n->level = -1;
for (i = 0; i < NODECARD; i++)
*/
Rect_t NodeCover(Node_t * n)
{
- register int i, flag;
+ int i, flag;
Rect_t r;
assert(n);
*/
int PickBranch(Rect_t * r, Node_t * n)
{
- register Rect_t *rr=0;
- register int i=0, flag=1, increase=0, bestIncr=0, area=0, bestArea=0;
+ Rect_t *rr=0;
+ int i=0, flag=1, increase=0, bestIncr=0, area=0, bestArea=0;
int best=0;
assert(r && n);
*/
int AddBranch(RTree_t * rtp, Branch_t * b, Node_t * n, Node_t ** new)
{
- register int i;
+ int i;
assert(b);
assert(n);
-----------------------------------------------------------------------------*/
void InitRect(Rect_t * r)
{
- register int i;
+ int i;
for (i = 0; i < NUMSIDES; i++)
r->boundary[i] = 0;
}
Rect_t NullRect()
{
Rect_t r;
- register int i;
+ int i;
r.boundary[0] = 1;
r.boundary[NUMDIMS] = -1;
-----------------------------------------------------------------------------*/
RandomRect(Rect_t * r)
{
- register int i, width;
+ int i, width;
for (i = 0; i < NUMDIMS; i++) {
/* width from 1 to 1000 / 4, more small ones */
width = rand() % (1000 / 4) + 1;
-----------------------------------------------------------------------------*/
SearchRect(Rect_t * search, Rect_t * data)
{
- register int i, j, size, center;
+ int i, j, size, center;
assert(search);
assert(data);
-----------------------------------------------------------------------------*/
void PrintRect(Rect_t * r)
{
- register int i;
+ int i;
assert(r);
fprintf(stderr, "rect:");
for (i = 0; i < NUMDIMS; i++)
#if LLONG_MAX > UINT_MAX
unsigned int RectArea(Rect_t * r)
{
- register int i;
+ int i;
unsigned int area;
assert(r);
#else
unsigned int RectArea(Rect_t * r)
{
- register int i;
+ int i;
unsigned int area=1, a=1;
assert(r);
#if 0 /*original code*/
int RectArea(Rect_t * r)
{
- register int i, area=1;
+ int i, area=1;
assert(r);
if (Undefined(r))
-----------------------------------------------------------------------------*/
Rect_t CombineRect(Rect_t * r, Rect_t * rr)
{
- register int i, j;
+ int i, j;
Rect_t new;
assert(r && rr);
-----------------------------------------------------------------------------*/
int Overlap(Rect_t * r, Rect_t * s)
{
- register int i, j;
+ int i, j;
assert(r && s);
for (i = 0; i < NUMDIMS; i++) {
-----------------------------------------------------------------------------*/
int Contained(Rect_t * r, Rect_t * s)
{
- register int i, j, result;
+ int i, j, result;
assert(r && s);
/* undefined rect is contained in any other */
-----------------------------------------------------------------------------*/
void SplitNode(RTree_t * rtp, Node_t * n, Branch_t * b, Node_t ** nn)
{
- register struct PartitionVars *p;
- register int level;
+ struct PartitionVars *p;
+ int level;
int area;
assert(n);
-----------------------------------------------------------------------------*/
static void GetBranches(RTree_t * rtp, Node_t * n, Branch_t * b)
{
- register int i;
+ int i;
assert(n);
assert(b);
-----------------------------------------------------------------------------*/
static void MethodZero(RTree_t * rtp)
{
- register Rect_t *r;
- register int i, growth0, growth1, diff, biggestDiff;
- register int group, chosen = 0, betterGroup = 0;
+ Rect_t *r;
+ int i, growth0, growth1, diff, biggestDiff;
+ int group, chosen = 0, betterGroup = 0;
InitPVars(rtp);
PickSeeds(rtp);
-----------------------------------------------------------------------------*/
static void PickSeeds(RTree_t * rtp)
{
- register int i, j;
+ int i, j;
unsigned int waste, worst;
int seed0 = 0, seed1 = 0;
unsigned int area[NODECARD + 1];
static void LoadNodes(RTree_t * rtp, Node_t * n, Node_t * q,
struct PartitionVars *p)
{
- register int i;
+ int i;
assert(n);
assert(q);
assert(p);
-----------------------------------------------------------------------------*/
static void InitPVars(RTree_t * rtp)
{
- register int i;
+ int i;
rtp->split.Partitions[0].count[0] = rtp->split.Partitions[0].count[1] =
0;
-----------------------------------------------------------------------------*/
PrintPVars(RTree_t * rtp)
{
- register int i;
+ int i;
fprintf(stderr, "\npartition:\n");
for (i = 0; i < NODECARD + 1; i++) {
int lu_decompose(double **a, int n)
{
- register int i, j, k;
+ int i, j, k;
int pivotindex = 0;
double pivot, biggest, mult, tempf;
void lu_solve(double *x, double *b, int n)
{
- register int i, j;
+ int i, j;
double dot;
/* Vector reduction using U triangular matrix */
int matinv(double **A, double **Ainv, int n)
{
- register int i, j;
+ int i, j;
double *b, temp;
/* Decompose matrix into L and U triangular matrices */
{ /*a[n][n],b[n],c[n] */
double *asave, *csave;
double amax, dum, pivot;
- register int i, ii, j;
- register int k, m, mp;
- register int istar, ip;
- register int nm, nsq, t;
+ int i, ii, j;
+ int k, m, mp;
+ int istar, ip;
+ int nm, nsq, t;
istar = 0; /* quiet warnings */
nsq = n * n;
get_vertex_positions (int v0, int v1, int *ip, int *iq)
{
vertexchain_t *vp0, *vp1;
- register int i;
+ int i;
double angle, temp;
int tp = 0, tq = 0;
/* Get log*n for given n */
static int math_logstar_n(int n)
{
- register int i;
+ int i;
double v;
for (i = 0, v = (double) n; v >= 1; i++)
static int math_N(int n, int h)
{
- register int i;
+ int i;
double v;
for (i = 0, v = (int) n; i < h; i++)
int bsize;
} Dosdisc_t;
-static void addmapping(register Dosdisc_t * dp)
+static void addmapping(Dosdisc_t * dp)
{
- register int n;
+ int n;
if ((n = dp->maptop++) >= dp->mapsize) {
dp->mapsize *= 2;
if (!
}
static struct map *getmapping(Dosdisc_t * dp, off_t offset,
- register int whence)
+ int whence)
{
- register struct map *mp;
+ struct map *mp;
static struct map dummy;
if (offset <= dp->begin) {
dummy.logical = dummy.physical = offset;
static ssize_t dos_read(Sfio_t * iop, void *buff, size_t size,
Sfdisc_t * disc)
{
- register Dosdisc_t *dp = (Dosdisc_t *) disc;
- register char *cp = (char *) buff, *first, *cpmax;
- register int n, count, m;
+ Dosdisc_t *dp = (Dosdisc_t *) disc;
+ char *cp = (char *) buff, *first, *cpmax;
+ int n, count, m;
if (dp->extra) {
dp->extra = 0;
*cp = dp->last;
* otherwise, logical offset is converted to physical offset
*/
static off_t cur_offset(Dosdisc_t * dp, off_t offset, Sfio_t * iop,
- register int whence)
+ int whence)
{
- register off_t n, m = 0;
- register char *cp;
+ off_t n, m = 0;
+ char *cp;
if (whence == SEEK_CUR) {
whence = -1;
return (offset + m);
}
-static Sfoff_t dos_seek(Sfio_t * iop, Sfoff_t offset, register int whence,
+static Sfoff_t dos_seek(Sfio_t * iop, Sfoff_t offset, int whence,
Sfdisc_t * disc)
{
- register Dosdisc_t *dp = (Dosdisc_t *) disc;
+ Dosdisc_t *dp = (Dosdisc_t *) disc;
struct map dummy, *mp = 0;
off_t physical;
- register int n, size;
+ int n, size;
retry:
switch (whence) {
case SEEK_CUR:
static int dos_except(Sfio_t * iop, int type, void *arg, Sfdisc_t * disc)
{
- register Dosdisc_t *dp = (Dosdisc_t *) disc;
+ Dosdisc_t *dp = (Dosdisc_t *) disc;
if (type == SF_DPOP || type == SF_FINAL) {
if (dp->bsize > 0)
free((void *) dp->buff);
*/
int sfdcfilter(Sfio_t * f, const char *cmd)
{
- reg Filter_t *fi;
- reg Sfio_t *filter;
+ Filter_t *fi;
+ Sfio_t *filter;
/* open filter for read&write */
if (!(filter = sfpopen(NIL(Sfio_t *), cmd, "r+")))
{ 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
static int peek(Sfio_t * f, char_type ** bufp, int count,
- reg LZW_Disc * disc)
+ LZW_Disc * disc)
{
- reg int io_sz, j;
+ int io_sz, j;
if (count <= 0)
return count;
static code_int getcode(Sfio_t * f, LZW_Disc * disc)
{
- reg code_int code;
- reg int r_off, bits;
- reg char_type *bp;
+ code_int code;
+ int r_off, bits;
+ char_type *bp;
if (disc->clear_flg > 0
|| disc->gc_offset >= disc->gc_size
Sfdisc_t * sfdisc)
{
LZW_Disc *disc = (LZW_Disc *) sfdisc;
- reg char_type *stackp;
- reg code_int code;
+ char_type *stackp;
+ code_int code;
char *ioend = (char *) iobuf + iocnt;
- register char *ioptr = iobuf;
+ char *ioptr = iobuf;
#define END_REGS {disc->code=code;disc->stackp=stackp;}
#define BEGIN_REGS {code=disc->code;stackp=disc->stackp;}
int sfdcseekable(Sfio_t * f)
{
- reg Seek_t *sk;
+ Seek_t *sk;
/* see if already seekable */
if (sfseek(f, (Sfoff_t) 0, 1) >= 0)
static ssize_t streamio(Sfio_t * f, void * buf, size_t n,
Sfdisc_t * disc, int type)
{
- reg Subfile_t *su;
- reg Sfoff_t here, parent;
- reg ssize_t io;
+ Subfile_t *su;
+ Sfoff_t here, parent;
+ ssize_t io;
su = (Subfile_t *) disc;
static Sfoff_t streamseek(Sfio_t * f, Sfoff_t pos, int type,
Sfdisc_t * disc)
{
- reg Subfile_t *su;
- reg Sfoff_t here, parent;
+ Subfile_t *su;
+ Sfoff_t here, parent;
su = (Subfile_t *) disc;
int sfdcsubstream(Sfio_t * f, Sfio_t * parent, Sfoff_t offset,
Sfoff_t extent)
{
- reg Subfile_t *su;
- reg Sfoff_t here;
+ Subfile_t *su;
+ Sfoff_t here;
/* establish that we can seek to offset */
if ((here = sfseek(parent, (Sfoff_t) 0, 1)) < 0
static ssize_t teewrite(Sfio_t * f, const void * buf, size_t size,
Sfdisc_t * disc)
{
- reg Tee_t *te = (Tee_t *) disc;
+ Tee_t *te = (Tee_t *) disc;
/* tee data if still ok */
if (te->status == 0 && sfwrite(te->tee, buf, size) != (ssize_t) size)
*/
int sfdctee(Sfio_t * f, Sfio_t * tee)
{
- reg Tee_t *te;
+ Tee_t *te;
if (!(te = (Tee_t *) malloc(sizeof(Tee_t))))
return -1;
*/
static ssize_t unread(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc)
{
- reg Union_t *un;
- reg ssize_t r, m;
+ Union_t *un;
+ ssize_t r, m;
un = (Union_t *) disc;
m = n;
static Sfoff_t unseek(Sfio_t * f, Sfoff_t addr, int type, Sfdisc_t * disc)
{
- reg Union_t *un;
- reg int i;
- reg Sfoff_t extent, s;
+ Union_t *un;
+ int i;
+ Sfoff_t extent, s;
un = (Union_t *) disc;
if (un->type & UNSEEKABLE)
int sfdcunion(Sfio_t * f, Sfio_t ** array, int n)
{
- reg Union_t *un;
- reg int i;
+ Union_t *un;
+ int i;
if (n <= 0)
return -1;
#undef sfclrerr
-int sfclrerr(reg Sfio_t * f)
+int sfclrerr(Sfio_t * f)
{
return __sf_clrerr(f);
}
#undef sfdlen
-int sfdlen(reg Sfdouble_t v)
+int sfdlen(Sfdouble_t v)
{
return __sf_dlen(v);
}
#undef sfeof
-int sfeof(reg Sfio_t * f)
+int sfeof(Sfio_t * f)
{
return __sf_eof(f);
}
#undef sferror
-int sferror(reg Sfio_t * f)
+int sferror(Sfio_t * f)
{
return __sf_error(f);
}
#undef sffileno
-int sffileno(reg Sfio_t * f)
+int sffileno(Sfio_t * f)
{
return __sf_fileno(f);
}
#undef sfgetc
-int sfgetc(reg Sfio_t * f)
+int sfgetc(Sfio_t * f)
{
return __sf_getc(f);
}
#undef sfllen
-int sfllen(reg Sflong_t v)
+int sfllen(Sflong_t v)
{
return __sf_llen(v);
}
#undef sfputc
-int sfputc(reg Sfio_t * f, reg int c)
+int sfputc(Sfio_t * f, int c)
{
return __sf_putc(f, c);
}
#undef sfputd
-int sfputd(reg Sfio_t * f, Sfdouble_t d)
+int sfputd(Sfio_t * f, Sfdouble_t d)
{
return __sf_putd(f, d);
}
#undef sfputl
-int sfputl(reg Sfio_t * f, Sflong_t l)
+int sfputl(Sfio_t * f, Sflong_t l)
{
return __sf_putl(f, l);
}
#undef sfputm
-int sfputm(reg Sfio_t * f, Sfulong_t u, Sfulong_t m)
+int sfputm(Sfio_t * f, Sfulong_t u, Sfulong_t m)
{
return __sf_putm(f, u, m);
}
#undef sfputu
-int sfputu(reg Sfio_t * f, Sfulong_t u)
+int sfputu(Sfio_t * f, Sfulong_t u)
{
return __sf_putu(f, u);
}
#undef sfstacked
-int sfstacked(reg Sfio_t * f)
+int sfstacked(Sfio_t * f)
{
return __sf_stacked(f);
}
#undef sfulen
-int sfulen(reg Sfulong_t v)
+int sfulen(Sfulong_t v)
{
return __sf_ulen(v);
}
#undef sfvalue
-ssize_t sfvalue(reg Sfio_t * f)
+ssize_t sfvalue(Sfio_t * f)
{
return __sf_value(f);
}
** Written by Kiem-Phong Vo
*/
-int sfclose(reg Sfio_t * f)
+int sfclose(Sfio_t * f)
{
- reg int local, ex, rv;
+ int local, ex, rv;
void *data = NIL(void *);
SFMTXSTART(f, -1);
/* closing a stack of streams */
while (f->push) {
- reg Sfio_t *pop;
+ Sfio_t *pop;
if (!(pop = (*_Sfstack) (f, NIL(Sfio_t *))))
SFMTXRETURN(f, -1);
if (!local && f->pool) { /* remove from pool */
if (f->pool == &_Sfpool) {
- reg int n;
+ int n;
POOLMTXLOCK(&_Sfpool);
for (n = 0; n < _Sfpool.n_sf; ++n) {
**
** Written by Kiem-Phong Vo
*/
-int sfclrlock(reg Sfio_t * f)
+int sfclrlock(Sfio_t * f)
{
int rv;
*/
char *_sfcvt(void * dv, int n_digit, int *decpt, int *sign, int format)
{
- reg char *sp;
- reg long n, v;
- reg char *ep, *buf, *endsp;
+ char *sp;
+ long n, v;
+ char *ep, *buf, *endsp;
static char *Buf;
/* set up local buffer */
sp = ep;
else {
if ((format & SFFMT_EFORMAT) && *decpt == 0 && dval > 0.) {
- reg double d;
+ double d;
while ((int) (d = dval * 10.) == 0) {
dval = d;
*decpt -= 1;
** Written by Kiem-Phong Vo
*/
-Sfdisc_t *sfdisc(reg Sfio_t * f, reg Sfdisc_t * disc)
+Sfdisc_t *sfdisc(Sfio_t * f, Sfdisc_t * disc)
{
- reg Sfdisc_t *d, *rdisc;
- reg Sfread_f oreadf;
- reg Sfwrite_f owritef;
- reg Sfseek_f oseekf;
+ Sfdisc_t *d, *rdisc;
+ Sfread_f oreadf;
+ Sfwrite_f owritef;
+ Sfseek_f oseekf;
ssize_t n;
SFMTXSTART(f, NIL(Sfdisc_t *));
if (((f->mode & SF_WRITE) && (n = f->next - f->data) > 0) ||
((f->mode & SF_READ) && f->extent < 0
&& (n = f->endb - f->next) > 0)) {
- reg Sfexcept_f exceptf;
- reg int rv = 0;
+ Sfexcept_f exceptf;
+ int rv = 0;
exceptf = disc ? disc->exceptf :
f->disc ? f->disc->exceptf : NIL(Sfexcept_f);
}
if (!(f->flags & SF_STRING)) { /* this stream may have to be reinitialized */
- reg int reinit = 0;
+ int reinit = 0;
#define DISCF(dst,iof,type) (dst ? dst->iof : NIL(type))
#define REINIT(oiof,iof,type) \
if(!reinit) \
int _sfdlen(Sfdouble_t v)
{
#define N_ARRAY (16*sizeof(Sfdouble_t))
- reg int n, w;
+ int n, w;
Sfdouble_t x;
int exp;
*/
int _sfexcept(Sfio_t * f, int type, ssize_t io, Sfdisc_t * disc)
{
- reg int ev, local, lock;
- reg ssize_t size;
- reg uchar *data;
+ int ev, local, lock;
+ ssize_t size;
+ uchar *data;
SFMTXSTART(f, -1);
chk_stack:
if (local && f->push && ((type == SF_READ && f->next >= f->endb) || (type == SF_WRITE && f->next <= f->data))) { /* pop the stack */
- reg Sfio_t *pf;
+ Sfio_t *pf;
if (lock)
SFOPEN(f, 0);
* @param f fill the read buffer of this stream
* @param n see above
*/
-int _sffilbuf(Sfio_t * f, reg int n)
+int _sffilbuf(Sfio_t * f, int n)
{
- reg ssize_t r;
- reg int first, local, rcrv, rc, justseek;
+ ssize_t r;
+ int first, local, rcrv, rc, justseek;
SFMTXSTART(f, -1);
* @param f write out the buffered content of this stream
* @param c if c>=0, c is also written out
*/
-int _sfflsbuf(reg Sfio_t * f, reg int c)
+int _sfflsbuf(Sfio_t * f, int c)
{
- reg ssize_t n, w;
- reg uchar *data;
+ ssize_t n, w;
+ uchar *data;
uchar outc;
- reg int local, isall;
+ int local, isall;
int inpc = c;
SFMTXSTART(f, -1);
Sfdouble_t sfgetd(Sfio_t * f)
{
- reg uchar *s, *ends, c;
- reg int p, sign, exp;
+ uchar *s, *ends, c;
+ int p, sign, exp;
Sfdouble_t v;
SFMTXSTART(f, -1.);
** Written by Kiem-Phong Vo
*/
-Sflong_t sfgetl(reg Sfio_t * f)
+Sflong_t sfgetl(Sfio_t * f)
{
Sflong_t v;
- reg uchar *s, *ends, c;
- reg int p;
+ uchar *s, *ends, c;
+ int p;
SFMTXSTART(f, (Sflong_t) (-1));
** Written by Kiem-Phong Vo
*/
-Sfulong_t sfgetm(reg Sfio_t * f, Sfulong_t m)
+Sfulong_t sfgetm(Sfio_t * f, Sfulong_t m)
{
Sfulong_t v;
- reg uchar *s, *ends, c;
- reg int p;
+ uchar *s, *ends, c;
+ int p;
SFMTXSTART(f, (Sfulong_t) (-1));
* @param rc record separator. r10 on Vax
* @param type
*/
-char *sfgetr(reg Sfio_t * f, reg int rc, int type)
+char *sfgetr(Sfio_t * f, int rc, int type)
{
- reg ssize_t n;
- reg uchar *s, *ends, *us;
- reg ssize_t un;
- reg int found;
- reg Sfrsrv_t *rsrv;
+ ssize_t n;
+ uchar *s, *ends, *us;
+ ssize_t un;
+ int found;
+ Sfrsrv_t *rsrv;
SFMTXSTART(f, NIL(char *));
** Written by Kiem-Phong Vo
*/
-Sfulong_t sfgetu(reg Sfio_t * f)
+Sfulong_t sfgetu(Sfio_t * f)
{
Sfulong_t v;
- reg uchar *s, *ends, c;
- reg int p;
+ uchar *s, *ends, c;
+ int p;
SFMTXSTART(f, (Sfulong_t) (-1));
/* short-hands */
#define NIL(t) ((t)0)
-#define reg register
#ifndef uchar
#define uchar unsigned char
#endif
/* done at exiting time */
static void _sfcleanup(void)
{
- reg Sfpool_t *p;
- reg Sfio_t *f;
- reg int n;
- reg int pool;
+ Sfpool_t *p;
+ Sfio_t *f;
+ int n;
+ int pool;
f = (Sfio_t *) Version; /* shut compiler warning */
/* put into discrete pool */
int _sfsetpool(Sfio_t * f)
{
- reg Sfpool_t *p;
- reg Sfio_t **array;
- reg int n, rv;
+ Sfpool_t *p;
+ Sfio_t **array;
+ int n, rv;
if (!_Sfcleanup) {
_Sfcleanup = _sfcleanup;
}
/* create an auxiliary buffer for sfgetr/sfreserve/sfputr */
-Sfrsrv_t *_sfrsrv(reg Sfio_t * f, reg ssize_t size)
+Sfrsrv_t *_sfrsrv(Sfio_t * f, ssize_t size)
{
Sfrsrv_t *rsrv, *rs;
* @param pid
* @param stdio stdio popen() does not reset SIGPIPE handler
*/
-int _sfpopen(reg Sfio_t * f, int fd, int pid, int stdio)
+int _sfpopen(Sfio_t * f, int fd, int pid, int stdio)
{
- reg Sfproc_t *p;
+ Sfproc_t *p;
if (f->proc)
return 0;
/**
* @param f stream to close
*/
-int _sfpclose(reg Sfio_t * f)
+int _sfpclose(Sfio_t * f)
{
Sfproc_t *p;
int pid, status;
* @param wanted desired mode
* @param local a local call
*/
-int _sfmode(reg Sfio_t * f, reg int wanted, reg int local)
+int _sfmode(Sfio_t * f, int wanted, int local)
{
Sfoff_t addr;
- reg int rv = 0;
+ int rv = 0;
SFONCE(); /* initialize mutexes */
Sfio_t *sfnew(Sfio_t * oldf, void * buf, size_t size, int file,
int flags)
{
- reg Sfio_t *f;
- reg int sflags;
+ Sfio_t *f;
+ int sflags;
SFONCE(); /* initialize mutexes */
* @param c char to be written
* @param number of time to repeat
*/
-ssize_t sfnputc(reg Sfio_t * f, reg int c, reg size_t n)
+ssize_t sfnputc(Sfio_t * f, int c, size_t n)
{
- reg uchar *ps;
- reg ssize_t p, w;
+ uchar *ps;
+ ssize_t p, w;
uchar buf[128];
- reg int local;
+ int local;
SFMTXSTART(f, -1);
* @param file file/string to be opened
* @param mode mode of the stream
*/
-Sfio_t *sfopen(reg Sfio_t * f, const char *file, const char *mode)
+Sfio_t *sfopen(Sfio_t * f, const char *file, const char *mode)
{
int fd, oldfd, oflags, sflags;
return NIL(Sfio_t *);
}
if (oflags & O_TRUNC) { /* truncate file */
- reg int tf;
+ int tf;
while ((tf = creat(file, SF_CREATMODE)) < 0 &&
errno == EINTR)
errno = 0;
return f;
}
-int _sftype(reg const char *mode, int *oflagsp, int *uflagp)
+int _sftype(const char *mode, int *oflagsp, int *uflagp)
{
- reg int sflags, oflags, uflag;
+ int sflags, oflags, uflag;
if (!mode)
return 0;
ssize_t sfpkrd(int fd, void * argbuf, size_t n, int rc, long tm,
int action)
{
- reg ssize_t r;
- reg int ntry, t;
- reg char *buf = (char *) argbuf, *endbuf;
+ ssize_t r;
+ int ntry, t;
+ char *buf = (char *) argbuf, *endbuf;
if (rc < 0 && tm < 0 && action <= 0)
return read(fd, buf, n);
/* successful peek, find the record end */
if (rc >= 0) {
- reg char *sp;
+ char *sp;
t = action == 0 ? 1 : action < 0 ? -action : action;
for (endbuf = (sp = buf) + r; sp < endbuf;)
* @param n number of streams in array
* @param tm the amount of time in ms to wait for selecting
*/
-int sfpoll(Sfio_t ** fa, reg int n, int tm)
+int sfpoll(Sfio_t ** fa, int n, int tm)
{
- reg int r, c, m;
- reg Sfio_t *f;
- reg Sfdisc_t *d;
- reg int *status, *check;
+ int r, c, m;
+ Sfio_t *f;
+ Sfdisc_t *d;
+ int *status, *check;
if (n <= 0 || !fa)
return -1;
** link list and during such walks may free up streams&pools. Free pools will be
** reused in newpool().
*/
-static int delpool(reg Sfpool_t * p)
+static int delpool(Sfpool_t * p)
{
POOLMTXSTART(p);
POOLMTXRETURN(p, 0);
}
-static Sfpool_t *newpool(reg int mode)
+static Sfpool_t *newpool(int mode)
{
- reg Sfpool_t *p, *last = &_Sfpool;
+ Sfpool_t *p, *last = &_Sfpool;
/* look to see if there is a free pool */
for (last = &_Sfpool, p = last->next; p; last = p, p = p->next) {
*/
static int _sfphead(Sfpool_t * p, Sfio_t * f, int n)
{
- reg Sfio_t *head;
- reg ssize_t k, w, v;
- reg int rv;
+ Sfio_t *head;
+ ssize_t k, w, v;
+ int rv;
POOLMTXSTART(p);
* @param f
* @param type <0 : deleting, 0: move-to-front, >0: inserting
*/
-static int _sfpmove(reg Sfio_t * f, reg int type)
+static int _sfpmove(Sfio_t * f, int type)
{
- reg Sfpool_t *p;
- reg int n;
+ Sfpool_t *p;
+ int n;
if (type > 0)
return _sfsetpool(f);
}
}
-Sfio_t *sfpool(reg Sfio_t * f, reg Sfio_t * pf, reg int mode)
+Sfio_t *sfpool(Sfio_t * f, Sfio_t * pf, int mode)
{
- reg Sfpool_t *p;
- reg Sfio_t *rv;
+ Sfpool_t *p;
+ Sfio_t *rv;
_Sfpmove = _sfpmove;
/* execute command directly if possible; else use the shell */
static void execute(const char *argcmd)
{
- reg char *s, *cmd, **argv, **p, *interp;
- reg int n;
+ char *s, *cmd, **argv, **p, *interp;
+ int n;
/* define interpreter */
if (!(interp = getenv("SHELL")) || !interp[0])
*/
Sfio_t *sfpopen(Sfio_t * f, const char *command, const char *mode)
{
- reg int pid, fd, pkeep, ckeep, sflags;
+ int pid, fd, pkeep, ckeep, sflags;
int stdio, parent[2], child[2];
Sfio_t sf;
/* set shell meta characters */
if (Meta[0] == 0) {
- reg char *s;
+ char *s;
Meta[0] = 1;
for (s = "!@#$%&*(){}[]:;<>~`'|\"\\"; *s; ++s)
Meta[(uchar) s[0]] = 1;
int sfprintf(Sfio_t * f, const char *form, ...)
{
va_list args;
- reg int rv;
+ int rv;
va_start(args, form);
rv = sfvprintf(f, form, args);
int sfvsprintf(char *s, int n, const char *form, va_list args)
{
Sfio_t f;
- reg int rv;
+ int rv;
if (!s || n <= 0)
return -1;
int sfsprintf(char *s, int n, const char *form, ...)
{
va_list args;
- reg int rv;
+ int rv;
va_start(args, form);
rv = sfvsprintf(s, n, form, args);
va_end(args);
char *sfprints(const char *form, ...)
{
va_list args;
- reg int rv;
+ int rv;
static Sfio_t *f;
va_start(args, form);
** Written by Kiem-Phong Vo.
*/
-int sfpurge(reg Sfio_t * f)
+int sfpurge(Sfio_t * f)
{
- reg int mode;
+ int mode;
SFMTXSTART(f, -1);
int _sfputd(Sfio_t * f, Sfdouble_t v)
{
#define N_ARRAY (16*sizeof(Sfdouble_t))
- reg ssize_t n, w;
- reg uchar *s, *ends;
+ ssize_t n, w;
+ uchar *s, *ends;
int exp;
uchar c[N_ARRAY];
double x;
* @param f write a portable long to this stream
* @param v the value to be written
*/
-int _sfputl(reg Sfio_t * f, Sflong_t v)
+int _sfputl(Sfio_t * f, Sflong_t v)
{
#define N_ARRAY (2*sizeof(Sflong_t))
- reg uchar *s, *ps;
- reg ssize_t n, p;
+ uchar *s, *ps;
+ ssize_t n, p;
uchar c[N_ARRAY];
SFMTXSTART(f, -1);
* @param v the unsigned value to be written
* @param max the max value of the range
*/
-int _sfputm(reg Sfio_t * f, Sfulong_t v, Sfulong_t max)
+int _sfputm(Sfio_t * f, Sfulong_t v, Sfulong_t max)
{
#define N_ARRAY (2*sizeof(Sfulong_t))
- reg uchar *s, *ps;
- reg ssize_t n, p;
+ uchar *s, *ps;
+ ssize_t n, p;
uchar c[N_ARRAY];
SFMTXSTART(f, -1);
* @param s string to write
* @param rc record separator
*/
-ssize_t sfputr(reg Sfio_t * f, const char *s, reg int rc)
+ssize_t sfputr(Sfio_t * f, const char *s, int rc)
{
- reg ssize_t p, n, w;
- reg uchar *ps;
+ ssize_t p, n, w;
+ uchar *ps;
SFMTXSTART(f, -1);
* @param
* @param
*/
-int _sfputu(reg Sfio_t * f, Sfulong_t v)
+int _sfputu(Sfio_t * f, Sfulong_t v)
{
#define N_ARRAY (2*sizeof(Sfulong_t))
- reg uchar *s, *ps;
- reg ssize_t n, p;
+ uchar *s, *ps;
+ ssize_t n, p;
uchar c[N_ARRAY];
SFMTXSTART(f, -1);
*/
int sfraise(Sfio_t * f, int type, void * data)
{
- reg Sfdisc_t *disc, *next, *d;
- reg int local, rv;
+ Sfdisc_t *disc, *next, *d;
+ int local, rv;
SFMTXSTART(f, -1);
/* synchronize unseekable write streams */
static void _sfwrsync(void)
{
- reg Sfpool_t *p;
- reg Sfio_t *f;
- reg int n;
+ Sfpool_t *p;
+ Sfio_t *f;
+ int n;
/* sync all pool heads */
for (p = _Sfpool.next; p; p = p->next) {
}
}
-ssize_t sfrd(reg Sfio_t * f, reg void * buf, reg size_t n,
+ssize_t sfrd(Sfio_t * f, void * buf, size_t n,
Sfdisc_t * disc)
{
Sfoff_t r;
- reg Sfdisc_t *dc;
- reg int local, dosync, oerrno;
+ Sfdisc_t *dc;
+ int local, dosync, oerrno;
unsigned rcrv;
SFMTXSTART(f, -1);
/* warn that a read is about to happen */
SFDISC(f, dc, readf);
if (dc && dc->exceptf && (f->flags & SF_IOCHECK)) {
- reg int rv;
+ int rv;
if (local)
SETLOCAL(f);
if ((rv = _sfexcept(f, SF_READ, n, dc)) > 0)
* @param n number of bytes to be read
* @param
*/
-ssize_t sfread(reg Sfio_t * f, void * buf, reg size_t n)
+ssize_t sfread(Sfio_t * f, void * buf, size_t n)
{
- reg uchar *s, *begs;
- reg ssize_t r;
- reg int local, justseek;
+ uchar *s, *begs;
+ ssize_t r;
+ int local, justseek;
SFMTXSTART(f, (ssize_t) (-1));
* @param size size of peek
* @param type LOCKR: lock stream, LASTR: last record
*/
-void *sfreserve(reg Sfio_t * f, ssize_t size, int type)
+void *sfreserve(Sfio_t * f, ssize_t size, int type)
{
- reg ssize_t n, sz;
- reg Sfrsrv_t *rsrv;
- reg void *data;
- reg int mode;
+ ssize_t n, sz;
+ Sfrsrv_t *rsrv;
+ void *data;
+ int mode;
SFMTXSTART(f, NIL(void *));
int sfscanf(Sfio_t * f, const char *form, ...)
{
va_list args;
- reg int rv;
+ int rv;
va_start(args, form);
rv = (f && form) ? sfvscanf(f, form, args) : -1;
va_end(args);
int sfsscanf(const char *s, const char *form, ...)
{
va_list args;
- reg int rv;
+ int rv;
va_start(args, form);
rv = (s && form) ? sfvsscanf(s, form, args) : -1;
va_end(args);
** Written by Kiem-Phong Vo.
*/
-int sfset(reg Sfio_t * f, reg int flags, reg int set)
+int sfset(Sfio_t * f, int flags, int set)
{
- reg int oflags;
+ int oflags;
SFMTXSTART(f, 0);
* @param buf new buffer
* @param size buffer size, -1 for default size
*/
-void *sfsetbuf(reg Sfio_t * f, reg void * buf, reg size_t size)
+void *sfsetbuf(Sfio_t * f, void * buf, size_t size)
{
- reg int sf_malloc;
- reg uchar *obuf;
- reg Sfdisc_t *disc;
- reg ssize_t osize, blksize;
- reg int oflags, init, local;
+ int sf_malloc;
+ uchar *obuf;
+ Sfdisc_t *disc;
+ ssize_t osize, blksize;
+ int oflags, init, local;
Stat_t st;
SFONCE();
f->flags |= SF_LINE;
#ifdef HAVE_SYS_STAT_H
else { /* special case /dev/null */
- reg int dev, ino;
+ int dev, ino;
dev = (int) st.st_dev;
ino = (int) st.st_ino;
if (stat(DEVNULL, &st) >= 0 &&
** Written by Kiem-Phong Vo.
*/
-static int _sfdup(reg int fd, reg int newfd)
+static int _sfdup(int fd, int newfd)
{
- reg int dupfd;
+ int dupfd;
#ifdef F_DUPFD /* the simple case */
while ((dupfd = fcntl(fd, F_DUPFD, newfd)) < 0 && errno == EINTR)
#endif
}
-int sfsetfd(reg Sfio_t * f, reg int newfd)
+int sfsetfd(Sfio_t * f, int newfd)
{
- reg int oldfd;
+ int oldfd;
SFMTXSTART(f, -1);
**
** Written by Kiem-Phong Vo.
*/
-Sfoff_t sfsize(reg Sfio_t * f)
+Sfoff_t sfsize(Sfio_t * f)
{
Sfdisc_t *disc;
- reg int mode;
+ int mode;
Sfoff_t s;
SFMTXSTART(f, (Sfoff_t) (-1));
**
** Written by Kiem-Phong Vo.
*/
-Sfoff_t sfsk(reg Sfio_t * f, Sfoff_t addr, reg int type, Sfdisc_t * disc)
+Sfoff_t sfsk(Sfio_t * f, Sfoff_t addr, int type, Sfdisc_t * disc)
{
Sfoff_t p;
- reg Sfdisc_t *dc;
- reg ssize_t s;
- reg int local, mode;
+ Sfdisc_t *dc;
+ ssize_t s;
+ int local, mode;
SFMTXSTART(f, (Sfoff_t) (-1));
*/
Sfio_t *sfstack(Sfio_t * f1, Sfio_t * f2)
{
- reg int n;
- reg Sfio_t *rf;
- reg Sfrsrv_t *rsrv;
- reg Vtmutex_t *mtx;
+ int n;
+ Sfio_t *rf;
+ Sfrsrv_t *rsrv;
+ Vtmutex_t *mtx;
STKMTXLOCK(f1, f2);
#define FPART 1 /* doing fractional part */
#define EPART 2 /* doing exponent part */
-static Sfdouble_t sfpow10(reg int n)
+static Sfdouble_t sfpow10(int n)
{
Sfdouble_t dval;
* @param s string to convert
* @param retp to return the remainder of string
*/
-Sfdouble_t _sfstrtod(reg const char *s, char **retp)
+Sfdouble_t _sfstrtod(const char *s, char **retp)
{
- reg int n, c, m;
- reg int mode, fexp, sign, expsign;
+ int n, c, m;
+ int mode, fexp, sign, expsign;
Sfdouble_t dval;
char decpoint = 0, thousand;
SFSETLOCALE(decpoint, thousand);
** Written by Kiem-Phong Vo.
*/
-Sfio_t *sfswap(reg Sfio_t * f1, reg Sfio_t * f2)
+Sfio_t *sfswap(Sfio_t * f1, Sfio_t * f2)
{
Sfio_t tmp;
int f1pool, f2pool, f1mode, f1flags, f2flags;
static int _sfall(void)
{
- reg Sfpool_t *p, *next;
- reg Sfio_t *f;
- reg int n, rv;
- reg int nsync, count, loop;
+ Sfpool_t *p, *next;
+ Sfio_t *f;
+ int n, rv;
+ int nsync, count, loop;
#define MAXLOOP 3
for (loop = 0; loop < MAXLOOP; ++loop) {
/**
* @param f stream to be synchronized
*/
-int sfsync(reg Sfio_t * f)
+int sfsync(Sfio_t * f)
{
int local, rv, mode;
Sfio_t *origf;
goto next;
if ((f->mode & SF_WRITE) && (f->next > f->data || (f->bits & SF_HOLE))) { /* sync the buffer, make sure pool don't move */
- reg int pool = f->mode & SF_POOL;
+ int pool = f->mode & SF_POOL;
f->mode &= ~SF_POOL;
if (f->next > f->data && (SFWRALL(f), SFFLSBUF(f, -1)) < 0)
rv = -1;
/* function to initialize conversion tables */
static int sfcvinit(void)
{
- reg int d, l;
+ int d, l;
for (d = 0; d <= SF_MAXCHAR; ++d) {
_Sfcv36[d] = SF_RADIX;
** Written by Kiem-Phong Vo.
*/
-Sfoff_t sftell(reg Sfio_t * f)
+Sfoff_t sftell(Sfio_t * f)
{
- reg int mode;
+ int mode;
Sfoff_t p;
SFMTXSTART(f, (Sfoff_t) (-1));
static int _tmprmfile(Sfio_t * f, int type, void * val, Sfdisc_t * disc)
{
- reg File_t *ff, *last;
+ File_t *ff, *last;
NOTUSED(val);
static void _rmfiles(void)
{
- reg File_t *ff, *next;
+ File_t *ff, *next;
vtmtxlock(_Sfmutex);
for (ff = File; ff; ff = next) {
static int _rmtmp(Sfio_t * f, char *file)
{
#if _tmp_rmfail /* remove only when stream is closed */
- reg File_t *ff;
+ File_t *ff;
if (!File)
atexit(_rmfiles);
char **_sfgetpath(char *path)
{
- reg char *p, **dirs;
- reg int n;
+ char *p, **dirs;
+ int n;
if (!(path = getenv(path)))
return NIL(char **);
static int _tmpfd(Sfio_t * f)
{
- reg char *file;
- reg int fd;
+ char *file;
+ int fd;
int t;
/* set up path of dirs to create temp files */
for (t = 0; t < 10; ++t) { /* compute a random name */
static ulong Key, A;
if (A == 0 || t > 0) { /* get a quasi-random coefficient */
- reg int r;
+ int r;
A = (ulong) time(NIL(time_t *)) ^ (((ulong) (&t)) >> 3);
if (Key == 0)
Key = (A >> 16) | ((A & 0xffff) << 16);
static int _tmpexcept(Sfio_t * f, int type, void * val, Sfdisc_t * disc)
{
- reg int fd, m;
- reg Sfio_t *sf;
+ int fd, m;
+ Sfio_t *sf;
Sfio_t newf, savf;
void (*notifyf) (Sfio_t *, int, int);
return 1;
}
-Sfio_t *sftmp(reg size_t s)
+Sfio_t *sftmp(size_t s)
{
- reg Sfio_t *f;
+ Sfio_t *f;
static Sfdisc_t Tmpdisc =
{ NIL(Sfread_f), NIL(Sfwrite_f), NIL(Sfseek_f), _tmpexcept,
#if _tmp_rmfail
**
** Written by Kiem-Phong Vo.
*/
-static int _uexcept(reg Sfio_t * f, reg int type, void * val,
- reg Sfdisc_t * disc)
+static int _uexcept(Sfio_t * f, int type, void * val,
+ Sfdisc_t * disc)
{
NOTUSED(val);
* @param f push back one byte to this stream
* @param c the value to be pushed back
*/
-int sfungetc(reg Sfio_t * f, reg int c)
+int sfungetc(Sfio_t * f, int c)
{
- reg Sfio_t *uf;
+ Sfio_t *uf;
SFMTXSTART(f, -1)
/* space for data */
if (f->next == f->data) {
- reg uchar *data;
+ uchar *data;
if (f->size < 0)
f->size = 0;
if (!(data = (uchar *) malloc(f->size + 16))) {
*/
int sfvprintf(Sfio_t * f, const char *form, va_list args)
{
- reg int v = 0, n_s, base, fmt, flags;
+ int v = 0, n_s, base, fmt, flags;
Sflong_t lv;
- reg char *sp, *ssp, *endsp, *ep, *endep;
+ char *sp, *ssp, *endsp, *ep, *endep;
int dot, width, precis, n, n_output;
int sign, decpt;
ssize_t size;
char decimal = 0, thousand = 0;
/* fast io system */
- reg uchar *d, *endd;
- reg int w;
+ uchar *d, *endd;
+ int w;
#define SFBUF(f) (d = f->next, endd = f->endb)
#define SFINIT(f) (SFBUF(f), n_output = 0)
#define SFEND(f) ((n_output += d - f->next), (f->next = d))
lv = -lv;
}
if (n_s < 0) { /* base 10 */
- reg Sflong_t nv;
+ Sflong_t nv;
sfucvt(lv, sp, nv, ssp, Sflong_t, Sfulong_t);
} else if (n_s > 0) { /* base power-of-2 */
do {
* @param form format string
* @param accept accepted characters are set to 1
*/
-static char *setclass(reg char *form, reg char *accept)
+static char *setclass(char *form, char *accept)
{
- reg int fmt, c, yes;
+ int fmt, c, yes;
if ((fmt = *form++) == '^') { /* we want the complement of this set */
yes = 0;
* @param form scanning format
* @param args
*/
-int sfvscanf(Sfio_t * f, reg const char *form, va_list args)
+int sfvscanf(Sfio_t * f, const char *form, va_list args)
{
- reg uchar *d, *endd, *data;
- reg int inp, shift, base, width;
+ uchar *d, *endd, *data;
+ int inp, shift, base, width;
ssize_t size;
int fmt, flags, dot, n_assign, v, n, n_input;
char *sp;
goto done;
if (_Sftype[fmt] == SFFMT_FLOAT) {
- reg char *val;
- reg int dot, exponent;
+ char *val;
+ int dot, exponent;
val = accept;
if (width >= SF_MAXDIGITS)
*/
/* hole preserving writes */
-static ssize_t sfoutput(Sfio_t * f, reg char *buf, reg size_t n)
+static ssize_t sfoutput(Sfio_t * f, char *buf, size_t n)
{
- reg char *sp, *wbuf, *endbuf;
- reg ssize_t s, w, wr;
+ char *sp, *wbuf, *endbuf;
+ ssize_t s, w, wr;
s = w = 0;
wbuf = buf;
return w > 0 ? w : -1;
}
-ssize_t sfwr(reg Sfio_t * f, reg const void * buf, reg size_t n,
- reg Sfdisc_t * disc)
+ssize_t sfwr(Sfio_t * f, const void * buf, size_t n,
+ Sfdisc_t * disc)
{
- reg ssize_t w;
- reg Sfdisc_t *dc;
- reg int local, oerrno;
+ ssize_t w;
+ Sfdisc_t *dc;
+ int local, oerrno;
SFMTXSTART(f, (ssize_t) (-1));
else { /* warn that a write is about to happen */
SFDISC(f, dc, writef);
if (dc && dc->exceptf && (f->flags & SF_IOCHECK)) {
- reg int rv;
+ int rv;
if (local)
SETLOCAL(f);
if ((rv = _sfexcept(f, SF_WRITE, n, dc)) > 0)
* @param buf buffer to be written
* @param n number of bytes
*/
-ssize_t sfwrite(reg Sfio_t * f, const void * buf, reg size_t n)
+ssize_t sfwrite(Sfio_t * f, const void * buf, size_t n)
{
- reg uchar *s, *begs, *next;
- reg ssize_t w;
- reg int local;
+ uchar *s, *begs, *next;
+ ssize_t w;
+ int local;
SFMTXSTART(f, (ssize_t) (-1));
if (f->mode & SF_PKRD) { /* read past peeked data */
char buf[16];
- reg ssize_t r;
+ ssize_t r;
for (w = n; w > 0;) {
if ((r = w) > sizeof(buf))
* return a copy of s using vmalloc
*/
-char *vmstrdup(Vmalloc_t * v, register const char *s)
+char *vmstrdup(Vmalloc_t * v, const char *s)
{
- register char *t;
- register int n;
+ char *t;
+ int n;
return ((t =
vmalloc(v, n =
main(int argc, char *argv[])
{
- register char *p1;
- register char *p2;
- register int i, count;
+ char *p1;
+ char *p2;
+ int i, count;
int f1, f2;
int l1, l2;
int n1, n2, n;
}
static void expandPercentsEval(Tcl_Interp * interp, /* interpreter context */
- register char *before, /* Command with percent expressions */
+ char *before, /* Command with percent expressions */
char *r, /* vgpaneHandle string to substitute for "%r" */
int npts, /* number of coordinates */
point * ppos /* Cordinates to substitute for %t */
)
{
- register char *string;
+ char *string;
Tcl_DString scripts;
Tcl_DStringInit(&scripts);
# define YYCOPY(To, From, Count) \
do \
{ \
- register YYSIZE_T yyi; \
+ YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
const char *yystr;
# endif
{
- register const char *yys = yystr;
+ const char *yys = yystr;
while (*yys++ != '\0')
continue;
const char *yysrc;
# endif
{
- register char *yyd = yydest;
- register const char *yys = yysrc;
+ char *yyd = yydest;
+ const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
#endif
{
- register int yystate;
- register int yyn;
+ int yystate;
+ int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The state stack. */
short int yyssa[YYINITDEPTH];
short int *yyss = yyssa;
- register short int *yyssp;
+ short int *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
- register YYSTYPE *yyvsp;
+ YYSTYPE *yyvsp;
int getopt(int argc, char *const *argv, const char *opts)
{
static int sp = 1;
- register int c;
- register char *cp;
+ int c;
+ char *cp;
if (sp == 1) {
if (optind >= argc ||
projects / graphviz / commitdiff