chrissy
/
P8000
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ING_DB

This commit is contained in:
Oliver Lehmann 1989-02-10 10:54:47 +00:00
parent 7ebeb888df
commit 9626b72867
42 changed files with 4134 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
WEGA/contrib/ingres/dbs/src/struct/ACCBUF.c Normal file
View File

@ -0,0 +1,42 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register ACCBUF *d;
register int i;
ACCBUF desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct accbuf == ACCBUF [h/access.h]\n");
d = &desc;
off(&d->mainpg);
out("mainpg (long)");
off(&d->ovflopg);
out("ovflopg (long)");
off(&d->nxtlino);
out("nxtlino (short)");
off(d->firstup);
out("firstup (char [PGSIZE - PGHDR])");
off(d->linetab);
out("linetab (short [1])");
off(&d->rel_tupid);
out("rel_tupid (long)");
off(&d->thispage);
out("thispage (long)");
off(&d->filedesc);
out("filedesc (int)");
off(&d->modf);
out("modf (struct accbuf *)");
off(&d->modb);
out("modb (struct accbuf *)");
off(&d->bufstatus);
out("bufstatus (int)");
fflush(stdout);
}

26
WEGA/contrib/ingres/dbs/src/struct/ACCESSPARAM.c Normal file
View File

@ -0,0 +1,26 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/aux.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct accessparam *d;
register int i;
struct accessparam desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct accessparam [h/aux.h]\n");
d = &desc;
off(&d->mode);
out("mode (short)");
off(&d->sec_index);
out("sec_index (short)");
off(d->keydno);
out("keydno (char [MAXDOM + 1])");
fflush(stdout);
}

126
WEGA/contrib/ingres/dbs/src/struct/ADMIN.c Normal file
View File

@ -0,0 +1,126 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct admin *d;
register int i;
struct admin desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct admin [h/access.h]\n");
d = &desc;
off(&d->adhdr);
out("adhdr (struct adminhdr)");
off(d->adhdr.adowner);
out("adhdr.adowner (char [2])");
off(&d->adhdr.adflags);
out("adhdr.adflags (short)");
off(&d->adreld);
out("adreld (struct descriptor)");
off(&d->adreld.reldum);
out("adreld.reldum (struct relation)");
off(d->adreld.reldum.relid);
out("adreld.reldum.relid (char [MAXNAME])");
off(d->adreld.reldum.relowner);
out("adreld.reldum.relowner (char [2])");
off(&d->adreld.reldum.relspec);
out("adreld.reldum.relspec (char)");
off(&d->adreld.reldum.relindxd);
out("adreld.reldum.relindxd (char)");
# ifndef BIT_32
off(&d->adreld.reldum.relstat);
out("adreld.reldum.relstat (short)");
# endif
off(&d->adreld.reldum.relsave);
out("adreld.reldum.relsave (long)");
off(&d->adreld.reldum.reltups);
out("adreld.reldum.reltups (long)");
off(&d->adreld.reldum.relatts);
out("adreld.reldum.relatts (short)");
off(&d->adreld.reldum.relwid);
out("adreld.reldum.relwid (short)");
off(&d->adreld.reldum.relprim);
out("adreld.reldum.relprim (long)");
off(&d->adreld.reldum.relspare);
out("adreld.reldum.relspare (long)");
# ifdef BIT_32
off(&d->adreld.reldum.relstat);
out("adreld.reldum.relstat (short)");
# endif
off(&d->adreld.relfp);
out("adreld.relfp (short)");
off(&d->adreld.relopn);
out("adreld.relopn (short)");
off(&d->adreld.reltid);
out("adreld.reltid (long)");
off(&d->adreld.reladds);
out("adreld.reladds (long)");
off(d->adreld.reloff);
out("adreld.reloff (short [MAXDOM])");
off(d->adreld.relfrmt);
out("adreld.relfrmt (char [MAXDOM])");
off(d->adreld.relfrml);
out("adreld.relfrml (char [MAXDOM])");
off(d->adreld.relxtra);
out("adreld.relxtra (char [MAXDOM])");
off(d->adreld.relgiven);
out("adreld.relgiven (char [MAXDOM])");
off(&d->adattd);
out("adattd (struct descriptor)");
off(&d->adattd.reldum);
out("adattd.reldum (struct relation)");
off(d->adattd.reldum.relid);
out("adattd.reldum.relid (char [MAXNAME])");
off(d->adattd.reldum.relowner);
out("adattd.reldum.relowner (char [2])");
off(&d->adattd.reldum.relspec);
out("adattd.reldum.relspec (char)");
off(&d->adattd.reldum.relindxd);
out("adattd.reldum.relindxd (char)");
# ifndef BIT_32
off(&d->adattd.reldum.relstat);
out("adattd.reldum.relstat (short)");
# endif
off(&d->adattd.reldum.relsave);
out("adattd.reldum.relsave (long)");
off(&d->adattd.reldum.reltups);
out("adattd.reldum.reltups (long)");
off(&d->adattd.reldum.relatts);
out("adattd.reldum.relatts (short)");
off(&d->adattd.reldum.relwid);
out("adattd.reldum.relwid (short)");
off(&d->adattd.reldum.relprim);
out("adattd.reldum.relprim (long)");
off(&d->adattd.reldum.relspare);
out("adattd.reldum.relspare (long)");
# ifdef BIT_32
off(&d->adattd.reldum.relstat);
out("adattd.reldum.relstat (short)");
# endif
off(&d->adattd.relfp);
out("adattd.relfp (short)");
off(&d->adattd.relopn);
out("adattd.relopn (short)");
off(&d->adattd.reltid);
out("adattd.reltid (long)");
off(&d->adattd.reladds);
out("adattd.reladds (long)");
off(d->adattd.reloff);
out("adattd.reloff (short [MAXDOM])");
off(d->adattd.relfrmt);
out("adattd.relfrmt (char [MAXDOM])");
off(d->adattd.relfrml);
out("adattd.relfrml (char [MAXDOM])");
off(d->adattd.relxtra);
out("adattd.relxtra (char [MAXDOM])");
off(d->adattd.relgiven);
out("adattd.relgiven (char [MAXDOM])");
fflush(stdout);
}

24
WEGA/contrib/ingres/dbs/src/struct/ADMINHDR.c Normal file
View File

@ -0,0 +1,24 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct adminhdr *d;
register int i;
struct adminhdr desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct adminhdr [h/access.h]\n");
d = &desc;
off(d->adowner);
out("adowner (char [2])");
off(&d->adflags);
out("adflags (short)");
fflush(stdout);
}

28
WEGA/contrib/ingres/dbs/src/struct/AOP_NODE.c Normal file
View File

@ -0,0 +1,28 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register AOP_NODE *d;
register int i;
AOP_NODE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct aop_node == AOP_NODE [h/tree.h]\n");
d = &desc;
off(d->qt_hdr);
out("qt_hdr (char [QT_HDR_SIZ])");
off(d->var_hdr);
out("var_hdr (char [VAR_HDR_SIZ])");
off(&d->agfrmt);
out("agfrmt (char)");
off(&d->agfrml);
out("agfrml (char)");
fflush(stdout);
}

35
WEGA/contrib/ingres/dbs/src/struct/ATTRIBUTE.c Normal file
View File

@ -0,0 +1,35 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct attribute *d;
register int i;
struct attribute desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct attribute [h/ing_db.h]\n");
d = &desc;
off(d->attrelid);
out("attrelid (char [MAXNAME])");
off(d->attowner);
out("attowner (char [2])");
off(d->attname);
out("attname (char [MAXNAME])");
off(&d->attid);
out("attid (short)");
off(&d->attoff);
out("attoff (short)");
off(&d->attfrmt);
out("attfrmt (char)");
off(&d->attfrml);
out("attfrml (char)");
off(&d->attxtra);
out("attxtra (char)");
fflush(stdout);
}

25
WEGA/contrib/ingres/dbs/src/struct/BATCHBUF.c Normal file
View File

@ -0,0 +1,25 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# include "../h/batch.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct batchbuf *d;
register int i;
struct batchbuf desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct batchbuf [h/batch.h]\n");
d = &desc;
off(d->file_id);
out("file_id (char [IDSIZE])");
off(d->bbuf);
out("bbuf (char [BATCHSIZE])");
fflush(stdout);
}

55
WEGA/contrib/ingres/dbs/src/struct/BATCHHD.c Normal file
View File

@ -0,0 +1,55 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# include "../h/batch.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct batchhd *d;
register int i;
register int k;
struct batchhd desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct batchhd [h/batch.h]\n");
d = &desc;
off(d->db_name);
out("db_name (char [MAXNAME + 1])");
off(d->rel_name);
out("rel_name (char [MAXNAME + 1])");
off(d->userid);
out("userid (char [2])");
off(&d->num_updts);
out("num_updts (long)");
off(&d->mode_up);
out("mode_up (short)");
off(&d->tido_size);
out("tido_size (short)");
off(&d->tupo_size);
out("tupo_size (short)");
off(&d->tupn_size);
out("tupn_size (short)");
off(&d->tidn_size);
out("tidn_size (short)");
off(&d->si_dcount);
out("si_dcount (short)");
off(d->si);
out("si (struct si_doms [MAXDOM + 1])");
for (k = 0; k <= 1; k++)
{
off(&d->si[k]);
printf("%4d %06o #%04x:\tsi[%d] (struct si_doms)\n", i, i, i, k);
off(&d->si[k].rel_off);
printf("%4d %06o #%04x:\tsi[%d].rel_off (int)\n", i, i, i, k);
off(&d->si[k].tupo_off);
printf("%4d %06o #%04x:\tsi[%d].tupo_off (int)\n", i, i, i, k);
off(&d->si[k].dom_size);
printf("%4d %06o #%04x:\tsi[%d].dom_size (int)\n", i, i, i, k);
}
fflush(stdout);
}

1108
WEGA/contrib/ingres/dbs/src/struct/C.c Normal file
View File

File diff suppressed because it is too large Load Diff

20
WEGA/contrib/ingres/dbs/src/struct/DESC.adb Normal file
View File

@ -0,0 +1,20 @@
/"relid "12cn
.+12/"relowner "2cn
.+2/"relspec "bn
.+1/"relindxd "bn
.+1/"relstat "on
.+2/"relsave "Yn
.+4/"reltups "Dn
.+4/"relatts "dn
.+2/"relwid "dn
.+2/"relprim "Dn
.+4/"relspare "Dn
.+4/"relfp "dn
.+2/"relopn "dn
.+2/"reltid "Dn
.+4/"reladds "Dn
.+4/"reloff "7d
.+100/"relfrmt "7b
.+50/"relfrml "7b
.+50/"relxtra "7b
.+50/"relgivn "7b

67
WEGA/contrib/ingres/dbs/src/struct/DESC.c Normal file
View File

@ -0,0 +1,67 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register DESC *d;
register int i;
DESC desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct descriptor == DESC [h/ing_db.h]\n");
d = &desc;
off(&d->reldum);
out("reldum (struct relation)");
off(d->reldum.relid);
out("reldum.relid (char [MAXNAME])");
off(d->reldum.relowner);
out("reldum.relowner (char [2])");
off(&d->reldum.relspec);
out("reldum.relspec (char)");
off(&d->reldum.relindxd);
out("reldum.relindxd (char)");
# ifndef BIT_32
off(&d->reldum.relstat);
out("reldum.relstat (short)");
# endif
off(&d->reldum.relsave);
out("reldum.relsave (long)");
off(&d->reldum.reltups);
out("reldum.reltups (long)");
off(&d->reldum.relatts);
out("reldum.relatts (short)");
off(&d->reldum.relwid);
out("reldum.relwid (short)");
off(&d->reldum.relprim);
out("reldum.relprim (long)");
off(&d->reldum.relspare);
out("reldum.relspare (long)");
# ifdef BIT_32
off(&d->reldum.relstat);
out("reldum.relstat (short)");
# endif
off(&d->relfp);
out("relfp (short)");
off(&d->relopn);
out("relopn (short)");
off(&d->reltid);
out("reltid (long)");
off(&d->reladds);
out("reladds (long)");
off(d->reloff);
out("reloff (short [MAXDOM])");
off(d->relfrmt);
out("relfrmt (char [MAXDOM])");
off(d->relfrml);
out("relfrml (char [MAXDOM])");
off(d->relxtra);
out("relxtra (char [MAXDOM])");
off(d->relgiven);
out("relgiven (char [MAXDOM])");
fflush(stdout);
}

26
WEGA/contrib/ingres/dbs/src/struct/DESCXX.adb Normal file
View File

@ -0,0 +1,26 @@
/"relid "12cn
.+12/"relowner "2cn
.+2/"relspec "bn
.+1/"relindxd "bn
.+1/"relstat "on
.+2/"relsave "Yn
.+4/"reltups "Dn
.+4/"relatts "dn
.+2/"relwid "dn
.+2/"relprim "Dn
.+4/"relspare "Dn
.+4/"relfp "dn
.+2/"relopn "dn
.+2/"reltid "Dn
.+4/"reladds "Dn
.+4/"reloff "7d
.+100/"relfrmt "7b
.+50/"relfrml "7b
.+50/"relxtra "7b
.+50/"relgivn "7b
.+50/"xx_next "xn
.+2/"xx_index "xn
.+2/"xx_indom "xn
.+2/"xx_ta "xn
.+2/"xx_excl "dn
.+2/"xx_locks "dn

82
WEGA/contrib/ingres/dbs/src/struct/DESCXX.c Normal file
View File

@ -0,0 +1,82 @@
# include <stdio.h>
# include "../amx_lib/AA_liba.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register DESCXX *d;
register int i;
DESCXX desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct descxx == DESCXX [amx_lib/AA_liba.h]\n");
d = &desc;
off(&d->xx_desc);
out("xx_desc (DESC)");
off(&d->xx_desc.reldum);
out("xx_desc.reldum (struct relation)");
off(d->xx_desc.reldum.relid);
out("xx_desc.reldum.relid (char [MAXNAME])");
off(d->xx_desc.reldum.relowner);
out("xx_desc.reldum.relowner (char [2])");
off(&d->xx_desc.reldum.relspec);
out("xx_desc.reldum.relspec (char)");
off(&d->xx_desc.reldum.relindxd);
out("xx_desc.reldum.relindxd (char)");
# ifndef BIT_32
off(&d->xx_desc.reldum.relstat);
out("xx_desc.reldum.relstat (short)");
# endif
off(&d->xx_desc.reldum.relsave);
out("xx_desc.reldum.relsave (long)");
off(&d->xx_desc.reldum.reltups);
out("xx_desc.reldum.reltups (long)");
off(&d->xx_desc.reldum.relatts);
out("xx_desc.reldum.relatts (short)");
off(&d->xx_desc.reldum.relwid);
out("xx_desc.reldum.relwid (short)");
off(&d->xx_desc.reldum.relprim);
out("xx_desc.reldum.relprim (long)");
off(&d->xx_desc.reldum.relspare);
out("xx_desc.reldum.relspare (long)");
# ifdef BIT_32
off(&d->xx_desc.reldum.relstat);
out("xx_desc.reldum.relstat (short)");
# endif
off(&d->xx_desc.relfp);
out("xx_desc.relfp (short)");
off(&d->xx_desc.relopn);
out("xx_desc.relopn (short)");
off(&d->xx_desc.reltid);
out("xx_desc.reltid (long)");
off(&d->xx_desc.reladds);
out("xx_desc.reladds (long)");
off(d->xx_desc.reloff);
out("xx_desc.reloff (short [MAXDOM])");
off(d->xx_desc.relfrmt);
out("xx_desc.relfrmt (char [MAXDOM])");
off(d->xx_desc.relfrml);
out("xx_desc.relfrml (char [MAXDOM])");
off(d->xx_desc.relxtra);
out("xx_desc.relxtra (char [MAXDOM])");
off(d->xx_desc.relgiven);
out("xx_desc.relgiven (char [MAXDOM])");
off(&d->xx_next);
out("xx_next (DESCXX *)");
off(&d->xx_index);
out("xx_index (DESCXX *)");
off(&d->xx_indom);
out("xx_indom (char *)");
off(&d->xx_ta);
out("xx_ta (DESCXX *)");
off(&d->xx_refresh);
out("xx_refresh (char)");
off(&d->xx_excl);
out("xx_excl (char)");
off(&d->xx_locks);
out("xx_locks (short)");
fflush(stdout);
}

26
WEGA/contrib/ingres/dbs/src/struct/DESXX.c Normal file
View File

@ -0,0 +1,26 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/aux.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct desxx *d;
register int i;
struct desxx desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct desxx [h/aux.h]\n");
d = &desc;
off(&d->cach_relname);
out("cach_relname (char *)");
off(&d->cach_desc);
out("cach_desc (DESC *)");
off(&d->cach_alias);
out("cach_alias (DESC *)");
fflush(stdout);
}

30
WEGA/contrib/ingres/dbs/src/struct/INDEX.c Normal file
View File

@ -0,0 +1,30 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/catalog.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct index *d;
register int i;
struct index desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct index [h/catalog.h]\n");
d = &desc;
off(d->irelidp);
out("irelidp (char [MAXNAME])");
off(d->iownerp);
out("iownerp (char [2])");
off(d->irelidi);
out("irelidi (char [MAXNAME])");
off(&d->irelspeci);
out("irelspeci (char)");
off(d->idom);
out("idom (char [MAXKEYS])");
fflush(stdout);
}

37
WEGA/contrib/ingres/dbs/src/struct/INTEGRITY.c Normal file
View File

@ -0,0 +1,37 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/catalog.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct integrity *d;
register int i;
struct integrity desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct integrity [h/catalog.h]\n");
d = &desc;
off(d->intrelid);
out("intrelid (char [MAXNAME])");
off(d->intrelowner);
out("intrelowner (char [2])");
# ifdef BIT_32
off(&d->inttree);
out("inttree (short)");
off(d->intdomset);
out("intdomset (short [8])");
# else
off(d->intdomset);
out("intdomset (short [8])");
off(&d->inttree);
out("inttree (short)");
# endif
off(&d->intresvar);
out("intresvar (char)");
fflush(stdout);
}

28
WEGA/contrib/ingres/dbs/src/struct/LASTOK.c Normal file
View File

@ -0,0 +1,28 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/scanner.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
struct optab Optab[1];
struct optab Keyword[1];
main()
{
register struct lastok *d;
register int i;
struct lastok desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct lastok [h/scanner.h]\n");
d = &desc;
off(&d->toktyp);
out("toktyp (short)");
off(&d->tok);
out("tok (char *)");
off(&d->tokop);
out("tokop (short)");
fflush(stdout);
}

31
WEGA/contrib/ingres/dbs/src/struct/LOCKREQ.c Normal file
View File

@ -0,0 +1,31 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/lock.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register LOCKREQ *d;
register int i;
LOCKREQ desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct lockreq == LOCKREQ [h/lock.h]\n");
d = &desc;
off(&d->l_db);
out("l_db (long)");
off(&d->l_rel);
out("l_rel (long)");
off(&d->l_page);
out("l_page (long)");
off(&d->l_act);
out("l_act (char)");
off(&d->l_mode);
out("l_mode (char)");
off(&d->l_pid);
out("l_pid (short)");
fflush(stdout);
}

1
WEGA/contrib/ingres/dbs/src/struct/OFFEN Normal file
View File

@ -0,0 +1 @@
../h/access.h struct tup_hdr

28
WEGA/contrib/ingres/dbs/src/struct/OPTAB.c Normal file
View File

@ -0,0 +1,28 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/scanner.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
struct optab Optab[1];
struct optab Keyword[1];
main()
{
register struct optab *d;
register int i;
struct optab desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct optab [h/scanner.h]\n");
d = &desc;
off(&d->term);
out("term (char *)");
off(&d->token);
out("token (short)");
off(&d->opcode);
out("opcode (short)");
fflush(stdout);
}

24
WEGA/contrib/ingres/dbs/src/struct/OP_NODE.c Normal file
View File

@ -0,0 +1,24 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register OP_NODE *d;
register int i;
OP_NODE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct op_node == OP_NODE [h/tree.h]\n");
d = &desc;
off(d->qt_hdr);
out("qt_hdr (char [QT_HDR_SIZ])");
off(&d->opno);
out("opno (short)");
fflush(stdout);
}

50
WEGA/contrib/ingres/dbs/src/struct/OUT_ARG.c Normal file
View File

@ -0,0 +1,50 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/aux.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct out_arg *d;
register int i;
struct out_arg desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct out_arg [h/aux.h]\n");
d = &desc;
off(&d->c0width);
out("c0width (short)");
off(&d->i1width);
out("i1width (short)");
off(&d->i2width);
out("i2width (short)");
off(&d->i4width);
out("i4width (short)");
# ifndef NO_F4
off(&d->f4width);
out("f4width (short)");
# endif
off(&d->f8width);
out("f8width (short)");
# ifndef NO_F4
off(&d->f4prec);
out("f4prec (short)");
# endif
off(&d->f8prec);
out("f8prec (short)");
# ifndef NO_F4
off(&d->f4style);
out("f4style (char)");
# endif
off(&d->f8style);
out("f8style (char)");
off(&d->linesperpage);
out("linesperpage (short)");
off(&d->coldelim);
out("coldelim (char)");
fflush(stdout);
}

63
WEGA/contrib/ingres/dbs/src/struct/PGTUPLE.c Normal file
View File

@ -0,0 +1,63 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(x) printf("%4d %04o #%04x:\t%s\n", i, i, i, x)
main()
{
register struct pgtuple *d;
register int i;
struct pgtuple desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct pgtuple\n");
d = &desc;
# ifdef REV_BYTES
# ifdef REV_WORDS
off(&d->childtid.line_id);
out("childtid.line_id");
off(&d->childtid.pg2);
out("childtid.pg2");
off(&d->childtid.pg1);
out("childtid.pg1");
off(&d->childtid.pg0);
out("childtid.pg0");
# else
off(&d->childtid.pg1);
out("childtid.pg1");
off(&d->childtid.pg0);
out("childtid.pg0");
off(&d->childtid.line_id);
out("childtid.line_id");
off(&d->childtid.pg2);
out("childtid.pg2");
# endif
# else
# ifdef REV_WORDS
off(&d->childtid.pg2);
out("childtid.pg2");
off(&d->childtid.line_id);
out("childtid.line_id");
off(&d->childtid.pg0);
out("childtid.pg0");
off(&d->childtid.pg1);
out("childtid.pg1");
# else
off(&d->childtid.pg0);
out("childtid.pg0");
off(&d->childtid.pg1);
out("childtid.pg1");
off(&d->childtid.pg2);
out("childtid.pg2");
off(&d->childtid.line_id);
out("childtid.line_id");
# endif
# endif
off(d->childtup);
out("childtup");
fflush(stdout);
}

35
WEGA/contrib/ingres/dbs/src/struct/PIPFRMT.c Normal file
View File

@ -0,0 +1,35 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/pipes.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct pipfrmt *d;
register int i;
struct pipfrmt desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct pipfrmt [h/pipes.h]\n");
d = &desc;
off(&d->exec_id);
out("exec_id (char)");
off(&d->func_id);
out("func_id (char)");
off(&d->buf_len);
out("buf_len (short)");
off(&d->err_id);
out("err_id (short)");
off(&d->hdrstat);
out("hdrstat (char)");
off(&d->param_id);
out("param_id (char)");
off(d->pbuf);
out("pbuf (char [PBUFSIZ])");
off(&d->pbuf_pt);
out("pbuf_pt (int)");
fflush(stdout);
}

46
WEGA/contrib/ingres/dbs/src/struct/PROTECT.c Normal file
View File

@ -0,0 +1,46 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/catalog.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct protect *d;
register int i;
struct protect desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct protect [h/catalog.h]\n");
d = &desc;
off(d->prorelid);
out("prorelid (char [MAXNAME])");
off(d->prorelown);
out("prorelown (char [2])");
off(&d->propermid);
out("propermid (short)");
off(d->prouser);
out("prouser (char [2])");
off(d->proterm);
out("proterm (char [PROTERM])");
off(&d->proresvar);
out("proresvar (char)");
off(&d->proopset);
out("proopset (char)");
off(&d->protodbgn);
out("protodbgn (short)");
off(&d->protodend);
out("protodend (short)");
off(&d->prodowbgn);
out("prodowbgn (char)");
off(&d->prodowend);
out("prodowend (char)");
off(d->prodomset);
out("prodomset (short [8])");
off(&d->protree);
out("protree (short)");
fflush(stdout);
}

36
WEGA/contrib/ingres/dbs/src/struct/QTREE.c Normal file
View File

@ -0,0 +1,36 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register QTREE *d;
register int i;
QTREE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct querytree == QREE [h/tree.h]\n");
d = &desc;
off(&d->left);
out("left (struct querytree *)");
off(&d->right);
out("right (struct querytree *)");
off(&d->sym);
out("sym (struct symbol)");
off(&d->sym.type);
out("sym.type (char)");
off(&d->sym.len);
out("sym.len (char)");
# ifdef BIT_32
off(&d->sym.aligned);
out("sym.aligned (short)");
# endif
off(d->sym.value);
out("sym.value (short [1])");
fflush(stdout);
}

30
WEGA/contrib/ingres/dbs/src/struct/REFS.c Normal file
View File

@ -0,0 +1,30 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/catalog.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct refs *d;
register int i;
struct refs desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct refs [h/catalog.h]\n");
d = &desc;
off(d->refrelid);
out("refrelid (char [MAXNAME])");
off(d->refowner);
out("refowner (char [2])");
off(d->refbrelid);
out("refbrelid (char [MAXNAME])");
off(d->refbowner);
out("refbowner (char [2])");
off(&d->reftype);
out("reftype (char)");
fflush(stdout);
}

47
WEGA/contrib/ingres/dbs/src/struct/RELATION.c Normal file
View File

@ -0,0 +1,47 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct relation *d;
register int i;
struct relation desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct relation [h/ing_db.h]\n");
d = &desc;
off(d->relid);
out("relid (char [MAXNAME])");
off(d->relowner);
out("relowner (char [2])");
off(&d->relspec);
out("relspec (char)");
off(&d->relindxd);
out("relindxd (char)");
# ifndef BIT_32
off(&d->relstat);
out("relstat (short)");
# endif
off(&d->relsave);
out("relsave (long)");
off(&d->reltups);
out("reltups (long)");
off(&d->relatts);
out("relatts (short)");
off(&d->relwid);
out("relwid (short)");
off(&d->relprim);
out("relprim (long)");
off(&d->relspare);
out("relspare (long)");
# ifdef BIT_32
off(&d->relstat);
out("relstat (short)");
# endif
fflush(stdout);
}

24
WEGA/contrib/ingres/dbs/src/struct/RES_NODE.c Normal file
View File

@ -0,0 +1,24 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register RES_NODE *d;
register int i;
RES_NODE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct res_node == RES_NODE [h/tree.h]\n");
d = &desc;
off(d->qt_hdr);
out("qt_hdr (char [QT_HDR_SIZ])");
off(&d->resno);
out("resno (short)");
fflush(stdout);
}

26
WEGA/contrib/ingres/dbs/src/struct/RETCODE.c Normal file
View File

@ -0,0 +1,26 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/aux.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct retcode *d;
register int i;
struct retcode desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct retcode [h/aux.h]\n");
d = &desc;
off(&d->rc_tupcount);
out("rc_tupcount (long)");
off(&d->rc_status);
out("rc_status (short)");
off(d->rc_siteid);
out("rc_siteid (char [2])");
fflush(stdout);
}

32
WEGA/contrib/ingres/dbs/src/struct/ROOT_NODE.c Normal file
View File

@ -0,0 +1,32 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register ROOT_NODE *d;
register int i;
ROOT_NODE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct root_node == ROOT_NODE [h/tree.h]\n");
d = &desc;
off(d->qt_hdr);
out("qt_hdr (char [QT_HDR_SIZ])");
off(&d->tvarc);
out("tvarc (char)");
off(&d->lvarc);
out("lvarc (char)");
off(&d->lvarm);
out("lvarm (short)");
off(&d->rvarm);
out("rvarm (short)");
off(&d->rootuser);
out("rootuser (short)");
fflush(stdout);
}

736
WEGA/contrib/ingres/dbs/src/struct/S.c Normal file
View File

@ -0,0 +1,736 @@
# include <stdio.h>
# include "../conf/gen.h"
# include "../h/ing_db.h"
# include "../h/symbol.h"
# include "../h/tree.h"
struct tab_of_op
{
int no_of_op;
char *name_of_op;
};
struct tab_of_op Tab_of_op[] =
{
1, "ACK", /* symbol.h */
2, "AGHEAD", /* symbol.h */
3, "AND", /* symbol.h */
4, "AND_SIZ", /* tree.h */
5, "AOP", /* symbol.h */
6, "AOP_SIZ", /* tree.h */
7, "BADCOP", /* symbol.h */
8, "BINARY", /* symbol.h */
9, "BOP", /* symbol.h */
10, "BYHEAD", /* symbol.h */
11, "CHANGESTRAT", /* symbol.h */
12, "CHAR", /* symbol.h */
13, "CID", /* symbol.h */
14, "COP", /* symbol.h */
15, "EMPTY", /* symbol.h */
16, "EOTUP", /* symbol.h */
17, "EXIT", /* symbol.h */
18, "FLOAT", /* symbol.h */
19, "INT", /* symbol.h */
20, "NOACK", /* symbol.h */
21, "NONEMPTY", /* symbol.h */
22, "NOUPDATE", /* symbol.h */
23, "OP_SIZ", /* tree.h */
24, "OR", /* symbol.h */
25, "PAT_ANY", /* symbol.h */
26, "PAT_LBRAC", /* symbol.h */
27, "PAT_ONE", /* symbol.h */
28, "PAT_RBRAC", /* symbol.h */
29, "QLEND", /* symbol.h */
30, "QMODE", /* symbol.h */
31, "QT_HDR_SIZ", /* tree.h */
32, "QT_PTR_SIZ", /* tree.h */
33, "REOPENRES", /* symbol.h */
34, "RESDOM", /* symbol.h */
35, "RESULTID", /* symbol.h */
36, "RESULTVAR", /* symbol.h */
37, "RES_SIZ", /* tree.h */
38, "RETVAL", /* symbol.h */
39, "ROOT", /* symbol.h */
40, "ROOT_SIZ", /* tree.h */
41, "RUBACK", /* symbol.h */
42, "SITE", /* symbol.h */
43, "SOURCEID", /* symbol.h */
44, "SRC_SIZ", /* tree.h */
45, "SVAR_SIZ", /* tree.h */
46, "SYM_HDR_SIZ", /* tree.h */
47, "S_VAR", /* symbol.h */
48, "TREE", /* symbol.h */
49, "TYP_LEN_SIZ", /* tree.h */
50, "UOP", /* symbol.h */
51, "UPDATE", /* symbol.h */
52, "USERQRY", /* symbol.h */
53, "VAR", /* symbol.h */
54, "VAR_HDR_SIZ", /* tree.h */
55, "VAR_SIZ", /* tree.h */
56, "mdAPP", /* symbol.h */
57, "mdCOPY", /* symbol.h */
58, "mdCREATE", /* symbol.h */
59, "mdDCREATE", /* symbol.h */
60, "mdDEFINE", /* symbol.h */
61, "mdDEL", /* symbol.h */
62, "mdDESTROY", /* symbol.h */
63, "mdDISPLAY", /* symbol.h */
64, "mdDISTRIB", /* symbol.h */
65, "mdHELP", /* symbol.h */
66, "mdINDEX", /* symbol.h */
67, "mdINTEG", /* symbol.h */
68, "mdMODIFY", /* symbol.h */
69, "mdMOVEREL", /* symbol.h */
70, "mdNETQRY", /* symbol.h */
71, "mdPRINT", /* symbol.h */
72, "mdPROT", /* symbol.h */
73, "mdRANGE", /* symbol.h */
74, "mdREMQM", /* symbol.h */
75, "mdREPL", /* symbol.h */
76, "mdRESETREL", /* symbol.h */
77, "mdRETR", /* symbol.h */
78, "mdRETTERM", /* symbol.h */
79, "mdRET_UNI", /* symbol.h */
80, "mdSAVE", /* symbol.h */
81, "mdUPDATE", /* symbol.h */
82, "mdVIEW", /* symbol.h */
83, "mdWAITQRY", /* symbol.h */
84, "opABS", /* symbol.h */
85, "opADD", /* symbol.h */
86, "opANY", /* symbol.h */
87, "opASCII", /* symbol.h */
88, "opATAN", /* symbol.h */
89, "opAVG", /* symbol.h */
90, "opAVGU", /* symbol.h */
91, "opCONCAT", /* symbol.h */
92, "opCOS", /* symbol.h */
93, "opCOUNT", /* symbol.h */
94, "opCOUNTU", /* symbol.h */
95, "opDATE", /* symbol.h */
96, "opDBA", /* symbol.h */
97, "opDIV", /* symbol.h */
98, "opEQ", /* symbol.h */
99, "opEXP", /* symbol.h */
100, "opFLOAT4", /* symbol.h */
101, "opFLOAT8", /* symbol.h */
102, "opGAMMA", /* symbol.h */
103, "opGE", /* symbol.h */
104, "opGT", /* symbol.h */
105, "opINT1", /* symbol.h */
106, "opINT2", /* symbol.h */
107, "opINT4", /* symbol.h */
108, "opLE", /* symbol.h */
109, "opLOG", /* symbol.h */
110, "opLT", /* symbol.h */
111, "opMAX", /* symbol.h */
112, "opMIN", /* symbol.h */
113, "opMINUS", /* symbol.h */
114, "opMOD", /* symbol.h */
115, "opMUL", /* symbol.h */
116, "opNE", /* symbol.h */
117, "opNOT", /* symbol.h */
118, "opPLUS", /* symbol.h */
119, "opPOW", /* symbol.h */
120, "opSIN", /* symbol.h */
121, "opSQRT", /* symbol.h */
122, "opSUB", /* symbol.h */
123, "opSUM", /* symbol.h */
124, "opSUMU", /* symbol.h */
125, "opTIME", /* symbol.h */
126, "opUSERCODE", /* symbol.h */
};
int No_of_ops = sizeof Tab_of_op / sizeof Tab_of_op[0];
main(argc, argv)
int argc;
char *argv[];
{
register int i;
char buf[BUFSIZ];
setbuf(stdout, buf);
if (argc == 1)
for (i = 1; i <= No_of_ops; i++)
const(i);
else
for (i = 1; i < argc; i++)
const(name(argv[i]));
}
name(chr)
char *chr;
{
register int hi;
register int lo;
register int curr;
/* is it a keyword ? */
lo = 0;
hi = No_of_ops - 1;
while (lo <= hi)
{
curr = (lo + hi) / 2;
switch (AAscompare(Tab_of_op[curr].name_of_op, 50, chr, 50))
{
case 1:
hi = curr - 1;
continue;
case -1:
lo = curr + 1;
continue;
case 0:
return (Tab_of_op[curr].no_of_op);
}
}
return (No_of_ops + 1);
}
AAscompare(ap, al, bp, bl)
register char *ap;
register int al;
register char *bp;
register int bl;
{
register int a;
register int b;
while (1)
{
/* supress blanks in both strings */
a = al? *ap: 0;
b = bl? *bp: 0;
/* do inequality tests */
if (a < b)
return (-1);
if (a > b)
return (1);
if (!a)
return (0);
/* go on to the next character */
ap++;
al--;
bp++;
bl--;
}
}
const(c)
register int c;
{
switch (c)
{
case 1:
printf("h/symbol.h\tACK\t\t%6d\n", ACK);
break;
case 2:
printf("h/symbol.h\tAGHEAD\t\t%6d\n", AGHEAD);
break;
case 3:
printf("h/symbol.h\tAND\t\t%6d\n", AND);
break;
case 4:
printf("h/tree.h\tAND_SIZ\t\t%6d\n", AND_SIZ);
break;
case 5:
printf("h/symbol.h\tAOP\t\t%6d\n", AOP);
break;
case 6:
printf("h/tree.h\tAOP_SIZ\t\t%6d\n", AOP_SIZ);
break;
case 7:
printf("h/symbol.h\tBADCOP\t\t%6d\n", BADCOP);
break;
case 8:
printf("h/symbol.h\tBINARY\t\t%6d\n", BINARY);
break;
case 9:
printf("h/symbol.h\tBOP\t\t%6d\n", BOP);
break;
case 10:
printf("h/symbol.h\tBYHEAD\t\t%6d\n", BYHEAD);
break;
case 11:
printf("h/symbol.h\tCHANGESTRAT\t%6d\n", CHANGESTRAT);
break;
case 12:
printf("h/symbol.h\tCHAR\t\t%6d\n", CHAR);
break;
case 13:
printf("h/symbol.h\tCID\t\t%6d\n", CID);
break;
case 14:
printf("h/symbol.h\tCOP\t\t%6d\n", COP);
break;
case 15:
printf("h/symbol.h\tEMPTY\t\t%6d\n", EMPTY);
break;
case 16:
printf("h/symbol.h\tEOTUP\t\t%6d\n", EOTUP);
break;
case 17:
printf("h/symbol.h\tEXIT\t\t%6d\n", EXIT);
break;
case 18:
printf("h/symbol.h\tFLOAT\t\t%6d\n", FLOAT);
break;
case 19:
printf("h/symbol.h\tINT\t\t%6d\n", INT);
break;
case 20:
printf("h/symbol.h\tNOACK\t\t%6d\n", NOACK);
break;
case 21:
printf("h/symbol.h\tNONEMPTY\t%6d\n", NONEMPTY);
break;
case 22:
printf("h/symbol.h\tNOUPDATE\t%6d\n", NOUPDATE);
break;
case 23:
printf("h/tree.h\tOP_SIZ\t\t%6d\n", OP_SIZ);
break;
case 24:
printf("h/symbol.h\tOR\t\t%6d\n", OR);
break;
case 25:
printf("h/symbol.h\tPAT_ANY\t\t%6d\n", PAT_ANY);
break;
case 26:
printf("h/symbol.h\tPAT_LBRAC\t%6d\n", PAT_LBRAC);
break;
case 27:
printf("h/symbol.h\tPAT_ONE\t\t%6d\n", PAT_ONE);
break;
case 28:
printf("h/symbol.h\tPAT_RBRAC\t%6d\n", PAT_RBRAC);
break;
case 29:
printf("h/symbol.h\tQLEND\t\t%6d\n", QLEND);
break;
case 30:
printf("h/symbol.h\tQMODE\t\t%6d\n", QMODE);
break;
case 31:
printf("h/tree.h\tQT_HDR_SIZ\t%6d\n", QT_HDR_SIZ);
break;
case 32:
printf("h/tree.h\tQT_PTR_SIZ\t%6d\n", QT_PTR_SIZ);
break;
case 33:
printf("h/symbol.h\tREOPENRES\t%6d\n", REOPENRES);
break;
case 34:
printf("h/symbol.h\tRESDOM\t\t%6d\n", RESDOM);
break;
case 35:
printf("h/symbol.h\tRESULTID\t%6d\n", RESULTID);
break;
case 36:
printf("h/symbol.h\tRESULTVAR\t%6d\n", RESULTVAR);
break;
case 37:
printf("h/tree.h\tRES_SIZ\t\t%6d\n", RES_SIZ);
break;
case 38:
printf("h/symbol.h\tRETVAL\t\t%6d\n", RETVAL);
break;
case 39:
printf("h/symbol.h\tROOT\t\t%6d\n", ROOT);
break;
case 40:
printf("h/tree.h\tROOT_SIZ\t%6d\n", ROOT_SIZ);
break;
case 41:
printf("h/symbol.h\tRUBACK\t\t%6d\n", RUBACK);
break;
case 42:
printf("h/symbol.h\tSITE\t\t%6d\n", SITE);
break;
case 43:
printf("h/symbol.h\tSOURCEID\t%6d\n", SOURCEID);
break;
case 44:
printf("h/tree.h\tSRC_SIZ\t\t%6d\n", SRC_SIZ);
break;
case 45:
printf("h/tree.h\tSVAR_SIZ\t%6d\n", SVAR_SIZ);
break;
case 46:
printf("h/tree.h\tSYM_HDR_SIZ\t%6d\n", SYM_HDR_SIZ);
break;
case 47:
printf("h/symbol.h\tS_VAR\t\t%6d\n", S_VAR);
break;
case 48:
printf("h/symbol.h\tTREE\t\t%6d\n", TREE);
break;
case 49:
printf("h/tree.h\tTYP_LEN_SIZ\t%6d\n", TYP_LEN_SIZ);
break;
case 50:
printf("h/symbol.h\tUOP\t\t%6d\n", UOP);
break;
case 51:
printf("h/symbol.h\tUPDATE\t\t%6d\n", UPDATE);
break;
case 52:
printf("h/symbol.h\tUSERQRY\t\t%6d\n", USERQRY);
break;
case 53:
printf("h/symbol.h\tVAR\t\t%6d\n", VAR);
break;
case 54:
printf("h/tree.h\tVAR_HDR_SIZ\t%6d\n", VAR_HDR_SIZ);
break;
case 55:
printf("h/tree.h\tVAR_SIZ\t\t%6d\n", VAR_SIZ);
break;
case 56:
printf("h/symbol.h\tmdAPP\t\t%6d\n", mdAPP);
break;
case 57:
printf("h/symbol.h\tmdCOPY\t\t%6d\n", mdCOPY);
break;
case 58:
printf("h/symbol.h\tmdCREATE\t%6d\n", mdCREATE);
break;
case 59:
printf("h/symbol.h\tmdDCREATE\t%6d\n", mdDCREATE);
break;
case 60:
printf("h/symbol.h\tmdDEFINE\t%6d\n", mdDEFINE);
break;
case 61:
printf("h/symbol.h\tmdDEL\t\t%6d\n", mdDEL);
break;
case 62:
printf("h/symbol.h\tmdDESTROY\t%6d\n", mdDESTROY);
break;
case 63:
printf("h/symbol.h\tmdDISPLAY\t%6d\n", mdDISPLAY);
break;
case 64:
printf("h/symbol.h\tmdDISTRIB\t%6d\n", mdDISTRIB);
break;
case 65:
printf("h/symbol.h\tmdHELP\t\t%6d\n", mdHELP);
break;
case 66:
printf("h/symbol.h\tmdINDEX\t\t%6d\n", mdINDEX);
break;
case 67:
printf("h/symbol.h\tmdINTEG\t\t%6d\n", mdINTEG);
break;
case 68:
printf("h/symbol.h\tmdMODIFY\t%6d\n", mdMODIFY);
break;
case 69:
printf("h/symbol.h\tmdMOVEREL\t%6d\n", mdMOVEREL);
break;
case 70:
printf("h/symbol.h\tmdNETQRY\t%6d\n", mdNETQRY);
break;
case 71:
printf("h/symbol.h\tmdPRINT\t\t%6d\n", mdPRINT);
break;
case 72:
printf("h/symbol.h\tmdPROT\t\t%6d\n", mdPROT);
break;
case 73:
printf("h/symbol.h\tmdRANGE\t\t%6d\n", mdRANGE);
break;
case 74:
printf("h/symbol.h\tmdREMQM\t\t%6d\n", mdREMQM);
break;
case 75:
printf("h/symbol.h\tmdREPL\t\t%6d\n", mdREPL);
break;
case 76:
printf("h/symbol.h\tmdRESETREL\t%6d\n", mdRESETREL);
break;
case 77:
printf("h/symbol.h\tmdRETR\t\t%6d\n", mdRETR);
break;
case 78:
printf("h/symbol.h\tmdRETTERM\t%6d\n", mdRETTERM);
break;
case 79:
printf("h/symbol.h\tmdRET_UNI\t%6d\n", mdRET_UNI);
break;
case 80:
printf("h/symbol.h\tmdSAVE\t\t%6d\n", mdSAVE);
break;
case 81:
printf("h/symbol.h\tmdUPDATE\t%6d\n", mdUPDATE);
break;
case 82:
printf("h/symbol.h\tmdVIEW\t\t%6d\n", mdVIEW);
break;
case 83:
printf("h/symbol.h\tmdWAITQRY\t%6d\n", mdWAITQRY);
break;
case 84:
printf("h/symbol.h\topABS\t\t%6d\n", opABS);
break;
case 85:
printf("h/symbol.h\topADD\t\t%6d\n", opADD);
break;
case 86:
printf("h/symbol.h\topANY\t\t%6d\n", opANY);
break;
case 87:
printf("h/symbol.h\topASCII\t\t%6d\n", opASCII);
break;
case 88:
printf("h/symbol.h\topATAN\t\t%6d\n", opATAN);
break;
case 89:
printf("h/symbol.h\topAVG\t\t%6d\n", opAVG);
break;
case 90:
printf("h/symbol.h\topAVGU\t\t%6d\n", opAVGU);
break;
case 91:
printf("h/symbol.h\topCONCAT\t%6d\n", opCONCAT);
break;
case 92:
printf("h/symbol.h\topCOS\t\t%6d\n", opCOS);
break;
case 93:
printf("h/symbol.h\topCOUNT\t\t%6d\n", opCOUNT);
break;
case 94:
printf("h/symbol.h\topCOUNTU\t%6d\n", opCOUNTU);
break;
case 95:
printf("h/symbol.h\topDATE\t\t%6d\n", opDATE);
break;
case 96:
printf("h/symbol.h\topDBA\t\t%6d\n", opDBA);
break;
case 97:
printf("h/symbol.h\topDIV\t\t%6d\n", opDIV);
break;
case 98:
printf("h/symbol.h\topEQ\t\t%6d\n", opEQ);
break;
case 99:
printf("h/symbol.h\topEXP\t\t%6d\n", opEXP);
break;
case 100:
printf("h/symbol.h\topFLOAT4\t%6d\n", opFLOAT4);
break;
case 101:
printf("h/symbol.h\topFLOAT8\t%6d\n", opFLOAT8);
break;
case 102:
printf("h/symbol.h\topGAMMA\t\t%6d\n", opGAMMA);
break;
case 103:
printf("h/symbol.h\topGE\t\t%6d\n", opGE);
break;
case 104:
printf("h/symbol.h\topGT\t\t%6d\n", opGT);
break;
case 105:
printf("h/symbol.h\topINT1\t\t%6d\n", opINT1);
break;
case 106:
printf("h/symbol.h\topINT2\t\t%6d\n", opINT2);
break;
case 107:
printf("h/symbol.h\topINT4\t\t%6d\n", opINT4);
break;
case 108:
printf("h/symbol.h\topLE\t\t%6d\n", opLE);
break;
case 109:
printf("h/symbol.h\topLOG\t\t%6d\n", opLOG);
break;
case 110:
printf("h/symbol.h\topLT\t\t%6d\n", opLT);
break;
case 111:
printf("h/symbol.h\topMAX\t\t%6d\n", opMAX);
break;
case 112:
printf("h/symbol.h\topMIN\t\t%6d\n", opMIN);
break;
case 113:
printf("h/symbol.h\topMINUS\t\t%6d\n", opMINUS);
break;
case 114:
printf("h/symbol.h\topMOD\t\t%6d\n", opMOD);
break;
case 115:
printf("h/symbol.h\topMUL\t\t%6d\n", opMUL);
break;
case 116:
printf("h/symbol.h\topNE\t\t%6d\n", opNE);
break;
case 117:
printf("h/symbol.h\topNOT\t\t%6d\n", opNOT);
break;
case 118:
printf("h/symbol.h\topPLUS\t\t%6d\n", opPLUS);
break;
case 119:
printf("h/symbol.h\topPOW\t\t%6d\n", opPOW);
break;
case 120:
printf("h/symbol.h\topSIN\t\t%6d\n", opSIN);
break;
case 121:
printf("h/symbol.h\topSQRT\t\t%6d\n", opSQRT);
break;
case 122:
printf("h/symbol.h\topSUB\t\t%6d\n", opSUB);
break;
case 123:
printf("h/symbol.h\topSUM\t\t%6d\n", opSUM);
break;
case 124:
printf("h/symbol.h\topSUMU\t\t%6d\n", opSUMU);
break;
case 125:
printf("h/symbol.h\topTIME\t\t%6d\n", opTIME);
break;
case 126:
printf("h/symbol.h\topUSERCODE\t%6d\n", opUSERCODE);
break;
default:
printf("illegal SYMBOL\n");
}
}

27
WEGA/contrib/ingres/dbs/src/struct/SI_DOMS.c Normal file
View File

@ -0,0 +1,27 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# include "../h/batch.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct si_doms *d;
register int i;
struct si_doms desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct si_doms [h/batch.h]\n");
d = &desc;
off(&d->rel_off);
out("rel_off (int)");
off(&d->tupo_off);
out("tupo_off (int)");
off(&d->dom_size);
out("dom_size (int)");
fflush(stdout);
}

40
WEGA/contrib/ingres/dbs/src/struct/SPECIAL.c Normal file
View File

@ -0,0 +1,40 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/scanner.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
struct optab Optab[1];
struct optab Keyword[1];
main()
{
register struct special *d;
register int i;
struct special desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct special [h/scanner.h]\n");
d = &desc;
off(&d->sconst);
out("sconst (short)");
off(&d->bgncmnt);
out("bgncmnt (short)");
off(&d->endcmnt);
out("endcmnt (short)");
off(&d->i2const);
out("i2const (short)");
off(&d->i4const);
out("i4const (short)");
# ifndef NO_F4
off(&d->f4const);
out("f4const (short)");
# endif
off(&d->f8const);
out("f8const (short)");
off(&d->name);
out("name (short)");
fflush(stdout);
}

30
WEGA/contrib/ingres/dbs/src/struct/SRCID.c Normal file
View File

@ -0,0 +1,30 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register SRCID *d;
register int i;
SRCID desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct srcid == SRCID [h/tree.h]\n");
d = &desc;
off(d->sym_hdr);
out("sym_hdr (char [SYM_HDR_SIZ])");
off(&d->srcvar);
out("srcvar (short)");
off(d->srcname);
out("srcname (char [MAXNAME])");
off(d->srcown);
out("srcown (char [2])");
off(&d->srcstat);
out("srcstat (short)");
fflush(stdout);
}

824
WEGA/contrib/ingres/dbs/src/struct/STRUCTS.VAX Normal file
View File

@ -0,0 +1,824 @@
++++++++++ ACCBUF ++++++++++
struct accbuf == ACCBUF
0 0000 #0000: mainpg
4 0004 #0004: ovflopg
8 0010 #0008: nxtlino
10 0012 #000a: firstup
4094 7776 #0ffe: linetab
4096 10000 #1000: rel_tupid
4100 10004 #1004: thispage
4104 10010 #1008: filedesc
4108 10014 #100c: modf
4112 10020 #1010: modb
4116 10024 #1014: bufstatus
++++++++++ ACCESSPARAM ++++++++++
struct accessparam
0 0000 #0000: mode
2 0002 #0002: sec_index
4 0004 #0004: keydno
++++++++++ ADMIN ++++++++++
struct admin
0 0000 #0000: adhdr.adowner
2 0002 #0002: adhdr.adflags
4 0004 #0004: adreld.reldum.relid
16 0020 #0010: adreld.reldum.relowner
18 0022 #0012: adreld.reldum.relspec
19 0023 #0013: adreld.reldum.relindxd
20 0024 #0014: adreld.reldum.relsave
24 0030 #0018: adreld.reldum.reltups
28 0034 #001c: adreld.reldum.relatts
30 0036 #001e: adreld.reldum.relwid
32 0040 #0020: adreld.reldum.relprim
36 0044 #0024: adreld.reldum.relspare
40 0050 #0028: adreld.reldum.relstat
44 0054 #002c: adreld.relfp
46 0056 #002e: adreld.relopn
48 0060 #0030: adreld.reltid
52 0064 #0034: adreld.reladds
56 0070 #0038: adreld.reloff
314 0472 #013a: adreld.relfrmt
443 0673 #01bb: adreld.relfrml
572 1074 #023c: adreld.relxtra
701 1275 #02bd: adreld.relgiven
832 1500 #0340: adattd.reldum.relid
844 1514 #034c: adattd.reldum.relowner
846 1516 #034e: adattd.reldum.relspec
847 1517 #034f: adattd.reldum.relindxd
848 1520 #0350: adattd.reldum.relsave
852 1524 #0354: adattd.reldum.reltups
856 1530 #0358: adattd.reldum.relatts
858 1532 #035a: adattd.reldum.relwid
860 1534 #035c: adattd.reldum.relprim
864 1540 #0360: adattd.reldum.relspare
868 1544 #0364: adattd.reldum.relstat
872 1550 #0368: adattd.relfp
874 1552 #036a: adattd.relopn
876 1554 #036c: adattd.reltid
880 1560 #0370: adattd.reladds
884 1564 #0374: adattd.reloff
1142 2166 #0476: adattd.relfrmt
1271 2367 #04f7: adattd.relfrml
1400 2570 #0578: adattd.relxtra
1529 2771 #05f9: adattd.relgiven
++++++++++ ADMINHDR ++++++++++
struct adminhdr
0 0000 #0000: adowner
2 0002 #0002: adflags
++++++++++ AOP_NODE ++++++++++
struct aop_node == AOP_NODE
0 0000 #0000: qt_hdr
12 0014 #000c: var_hdr
16 0020 #0010: agfrmt
17 0021 #0011: agfrml
++++++++++ ATTRIBUTE ++++++++++
struct attribute
0 0000 #0000: attrelid
12 0014 #000c: attowner
14 0016 #000e: attname
26 0032 #001a: attid
28 0034 #001c: attoff
30 0036 #001e: attfrmt
31 0037 #001f: attfrml
32 0040 #0020: attxtra
++++++++++ BATCHBUF ++++++++++
struct batchbuf
0 0000 #0000: file_id
6 0006 #0006: bbuf
++++++++++ BATCHHD ++++++++++
struct batchhd
0 0000 #0000: db_name
15 0017 #000f: rel_name
28 0034 #001c: userid
32 0040 #0020: num_updts
36 0044 #0024: mode_up
38 0046 #0026: tido_size
40 0050 #0028: tupo_size
42 0052 #002a: tupn_size
44 0054 #002c: tidn_size
46 0056 #002e: si_dcount
48 0060 #0030: si[ 0].rel_off
50 0062 #0032: si[ 0].tupo_off
52 0064 #0034: si[ 0].dom_size
54 0066 #0036: si[ 1].rel_off
56 0070 #0038: si[ 1].tupo_off
58 0072 #003a: si[ 1].dom_size
60 0074 #003c: si[ 2].rel_off
62 0076 #003e: si[ 2].tupo_off
64 0100 #0040: si[ 2].dom_size
66 0102 #0042: si[ 3].rel_off
68 0104 #0044: si[ 3].tupo_off
70 0106 #0046: si[ 3].dom_size
72 0110 #0048: si[ 4].rel_off
74 0112 #004a: si[ 4].tupo_off
76 0114 #004c: si[ 4].dom_size
78 0116 #004e: si[ 5].rel_off
80 0120 #0050: si[ 5].tupo_off
82 0122 #0052: si[ 5].dom_size
84 0124 #0054: si[ 6].rel_off
86 0126 #0056: si[ 6].tupo_off
88 0130 #0058: si[ 6].dom_size
90 0132 #005a: si[ 7].rel_off
92 0134 #005c: si[ 7].tupo_off
94 0136 #005e: si[ 7].dom_size
96 0140 #0060: si[ 8].rel_off
98 0142 #0062: si[ 8].tupo_off
100 0144 #0064: si[ 8].dom_size
102 0146 #0066: si[ 9].rel_off
104 0150 #0068: si[ 9].tupo_off
106 0152 #006a: si[ 9].dom_size
108 0154 #006c: si[10].rel_off
110 0156 #006e: si[10].tupo_off
112 0160 #0070: si[10].dom_size
114 0162 #0072: si[11].rel_off
116 0164 #0074: si[11].tupo_off
118 0166 #0076: si[11].dom_size
120 0170 #0078: si[12].rel_off
122 0172 #007a: si[12].tupo_off
124 0174 #007c: si[12].dom_size
126 0176 #007e: si[13].rel_off
128 0200 #0080: si[13].tupo_off
130 0202 #0082: si[13].dom_size
132 0204 #0084: si[14].rel_off
134 0206 #0086: si[14].tupo_off
136 0210 #0088: si[14].dom_size
138 0212 #008a: si[15].rel_off
140 0214 #008c: si[15].tupo_off
142 0216 #008e: si[15].dom_size
144 0220 #0090: si[16].rel_off
146 0222 #0092: si[16].tupo_off
148 0224 #0094: si[16].dom_size
150 0226 #0096: si[17].rel_off
152 0230 #0098: si[17].tupo_off
154 0232 #009a: si[17].dom_size
156 0234 #009c: si[18].rel_off
158 0236 #009e: si[18].tupo_off
160 0240 #00a0: si[18].dom_size
162 0242 #00a2: si[19].rel_off
164 0244 #00a4: si[19].tupo_off
166 0246 #00a6: si[19].dom_size
168 0250 #00a8: si[20].rel_off
170 0252 #00aa: si[20].tupo_off
172 0254 #00ac: si[20].dom_size
174 0256 #00ae: si[21].rel_off
176 0260 #00b0: si[21].tupo_off
178 0262 #00b2: si[21].dom_size
180 0264 #00b4: si[22].rel_off
182 0266 #00b6: si[22].tupo_off
184 0270 #00b8: si[22].dom_size
186 0272 #00ba: si[23].rel_off
188 0274 #00bc: si[23].tupo_off
190 0276 #00be: si[23].dom_size
192 0300 #00c0: si[24].rel_off
194 0302 #00c2: si[24].tupo_off
196 0304 #00c4: si[24].dom_size
198 0306 #00c6: si[25].rel_off
200 0310 #00c8: si[25].tupo_off
202 0312 #00ca: si[25].dom_size
204 0314 #00cc: si[26].rel_off
206 0316 #00ce: si[26].tupo_off
208 0320 #00d0: si[26].dom_size
210 0322 #00d2: si[27].rel_off
212 0324 #00d4: si[27].tupo_off
214 0326 #00d6: si[27].dom_size
216 0330 #00d8: si[28].rel_off
218 0332 #00da: si[28].tupo_off
220 0334 #00dc: si[28].dom_size
222 0336 #00de: si[29].rel_off
224 0340 #00e0: si[29].tupo_off
226 0342 #00e2: si[29].dom_size
228 0344 #00e4: si[30].rel_off
230 0346 #00e6: si[30].tupo_off
232 0350 #00e8: si[30].dom_size
234 0352 #00ea: si[31].rel_off
236 0354 #00ec: si[31].tupo_off
238 0356 #00ee: si[31].dom_size
240 0360 #00f0: si[32].rel_off
242 0362 #00f2: si[32].tupo_off
244 0364 #00f4: si[32].dom_size
246 0366 #00f6: si[33].rel_off
248 0370 #00f8: si[33].tupo_off
250 0372 #00fa: si[33].dom_size
252 0374 #00fc: si[34].rel_off
254 0376 #00fe: si[34].tupo_off
256 0400 #0100: si[34].dom_size
258 0402 #0102: si[35].rel_off
260 0404 #0104: si[35].tupo_off
262 0406 #0106: si[35].dom_size
264 0410 #0108: si[36].rel_off
266 0412 #010a: si[36].tupo_off
268 0414 #010c: si[36].dom_size
270 0416 #010e: si[37].rel_off
272 0420 #0110: si[37].tupo_off
274 0422 #0112: si[37].dom_size
276 0424 #0114: si[38].rel_off
278 0426 #0116: si[38].tupo_off
280 0430 #0118: si[38].dom_size
282 0432 #011a: si[39].rel_off
284 0434 #011c: si[39].tupo_off
286 0436 #011e: si[39].dom_size
288 0440 #0120: si[40].rel_off
290 0442 #0122: si[40].tupo_off
292 0444 #0124: si[40].dom_size
294 0446 #0126: si[41].rel_off
296 0450 #0128: si[41].tupo_off
298 0452 #012a: si[41].dom_size
300 0454 #012c: si[42].rel_off
302 0456 #012e: si[42].tupo_off
304 0460 #0130: si[42].dom_size
306 0462 #0132: si[43].rel_off
308 0464 #0134: si[43].tupo_off
310 0466 #0136: si[43].dom_size
312 0470 #0138: si[44].rel_off
314 0472 #013a: si[44].tupo_off
316 0474 #013c: si[44].dom_size
318 0476 #013e: si[45].rel_off
320 0500 #0140: si[45].tupo_off
322 0502 #0142: si[45].dom_size
324 0504 #0144: si[46].rel_off
326 0506 #0146: si[46].tupo_off
328 0510 #0148: si[46].dom_size
330 0512 #014a: si[47].rel_off
332 0514 #014c: si[47].tupo_off
334 0516 #014e: si[47].dom_size
336 0520 #0150: si[48].rel_off
338 0522 #0152: si[48].tupo_off
340 0524 #0154: si[48].dom_size
342 0526 #0156: si[49].rel_off
344 0530 #0158: si[49].tupo_off
346 0532 #015a: si[49].dom_size
348 0534 #015c: si[50].rel_off
350 0536 #015e: si[50].tupo_off
352 0540 #0160: si[50].dom_size
354 0542 #0162: si[51].rel_off
356 0544 #0164: si[51].tupo_off
358 0546 #0166: si[51].dom_size
360 0550 #0168: si[52].rel_off
362 0552 #016a: si[52].tupo_off
364 0554 #016c: si[52].dom_size
366 0556 #016e: si[53].rel_off
368 0560 #0170: si[53].tupo_off
370 0562 #0172: si[53].dom_size
372 0564 #0174: si[54].rel_off
374 0566 #0176: si[54].tupo_off
376 0570 #0178: si[54].dom_size
378 0572 #017a: si[55].rel_off
380 0574 #017c: si[55].tupo_off
382 0576 #017e: si[55].dom_size
384 0600 #0180: si[56].rel_off
386 0602 #0182: si[56].tupo_off
388 0604 #0184: si[56].dom_size
390 0606 #0186: si[57].rel_off
392 0610 #0188: si[57].tupo_off
394 0612 #018a: si[57].dom_size
396 0614 #018c: si[58].rel_off
398 0616 #018e: si[58].tupo_off
400 0620 #0190: si[58].dom_size
402 0622 #0192: si[59].rel_off
404 0624 #0194: si[59].tupo_off
406 0626 #0196: si[59].dom_size
408 0630 #0198: si[60].rel_off
410 0632 #019a: si[60].tupo_off
412 0634 #019c: si[60].dom_size
414 0636 #019e: si[61].rel_off
416 0640 #01a0: si[61].tupo_off
418 0642 #01a2: si[61].dom_size
420 0644 #01a4: si[62].rel_off
422 0646 #01a6: si[62].tupo_off
424 0650 #01a8: si[62].dom_size
426 0652 #01aa: si[63].rel_off
428 0654 #01ac: si[63].tupo_off
430 0656 #01ae: si[63].dom_size
432 0660 #01b0: si[64].rel_off
434 0662 #01b2: si[64].tupo_off
436 0664 #01b4: si[64].dom_size
438 0666 #01b6: si[65].rel_off
440 0670 #01b8: si[65].tupo_off
442 0672 #01ba: si[65].dom_size
444 0674 #01bc: si[66].rel_off
446 0676 #01be: si[66].tupo_off
448 0700 #01c0: si[66].dom_size
450 0702 #01c2: si[67].rel_off
452 0704 #01c4: si[67].tupo_off
454 0706 #01c6: si[67].dom_size
456 0710 #01c8: si[68].rel_off
458 0712 #01ca: si[68].tupo_off
460 0714 #01cc: si[68].dom_size
462 0716 #01ce: si[69].rel_off
464 0720 #01d0: si[69].tupo_off
466 0722 #01d2: si[69].dom_size
468 0724 #01d4: si[70].rel_off
470 0726 #01d6: si[70].tupo_off
472 0730 #01d8: si[70].dom_size
474 0732 #01da: si[71].rel_off
476 0734 #01dc: si[71].tupo_off
478 0736 #01de: si[71].dom_size
480 0740 #01e0: si[72].rel_off
482 0742 #01e2: si[72].tupo_off
484 0744 #01e4: si[72].dom_size
486 0746 #01e6: si[73].rel_off
488 0750 #01e8: si[73].tupo_off
490 0752 #01ea: si[73].dom_size
492 0754 #01ec: si[74].rel_off
494 0756 #01ee: si[74].tupo_off
496 0760 #01f0: si[74].dom_size
498 0762 #01f2: si[75].rel_off
500 0764 #01f4: si[75].tupo_off
502 0766 #01f6: si[75].dom_size
504 0770 #01f8: si[76].rel_off
506 0772 #01fa: si[76].tupo_off
508 0774 #01fc: si[76].dom_size
510 0776 #01fe: si[77].rel_off
512 1000 #0200: si[77].tupo_off
514 1002 #0202: si[77].dom_size
516 1004 #0204: si[78].rel_off
518 1006 #0206: si[78].tupo_off
520 1010 #0208: si[78].dom_size
522 1012 #020a: si[79].rel_off
524 1014 #020c: si[79].tupo_off
526 1016 #020e: si[79].dom_size
528 1020 #0210: si[80].rel_off
530 1022 #0212: si[80].tupo_off
532 1024 #0214: si[80].dom_size
534 1026 #0216: si[81].rel_off
536 1030 #0218: si[81].tupo_off
538 1032 #021a: si[81].dom_size
540 1034 #021c: si[82].rel_off
542 1036 #021e: si[82].tupo_off
544 1040 #0220: si[82].dom_size
546 1042 #0222: si[83].rel_off
548 1044 #0224: si[83].tupo_off
550 1046 #0226: si[83].dom_size
552 1050 #0228: si[84].rel_off
554 1052 #022a: si[84].tupo_off
556 1054 #022c: si[84].dom_size
558 1056 #022e: si[85].rel_off
560 1060 #0230: si[85].tupo_off
562 1062 #0232: si[85].dom_size
564 1064 #0234: si[86].rel_off
566 1066 #0236: si[86].tupo_off
568 1070 #0238: si[86].dom_size
570 1072 #023a: si[87].rel_off
572 1074 #023c: si[87].tupo_off
574 1076 #023e: si[87].dom_size
576 1100 #0240: si[88].rel_off
578 1102 #0242: si[88].tupo_off
580 1104 #0244: si[88].dom_size
582 1106 #0246: si[89].rel_off
584 1110 #0248: si[89].tupo_off
586 1112 #024a: si[89].dom_size
588 1114 #024c: si[90].rel_off
590 1116 #024e: si[90].tupo_off
592 1120 #0250: si[90].dom_size
594 1122 #0252: si[91].rel_off
596 1124 #0254: si[91].tupo_off
598 1126 #0256: si[91].dom_size
600 1130 #0258: si[92].rel_off
602 1132 #025a: si[92].tupo_off
604 1134 #025c: si[92].dom_size
606 1136 #025e: si[93].rel_off
608 1140 #0260: si[93].tupo_off
610 1142 #0262: si[93].dom_size
612 1144 #0264: si[94].rel_off
614 1146 #0266: si[94].tupo_off
616 1150 #0268: si[94].dom_size
618 1152 #026a: si[95].rel_off
620 1154 #026c: si[95].tupo_off
622 1156 #026e: si[95].dom_size
624 1160 #0270: si[96].rel_off
626 1162 #0272: si[96].tupo_off
628 1164 #0274: si[96].dom_size
630 1166 #0276: si[97].rel_off
632 1170 #0278: si[97].tupo_off
634 1172 #027a: si[97].dom_size
636 1174 #027c: si[98].rel_off
638 1176 #027e: si[98].tupo_off
640 1200 #0280: si[98].dom_size
642 1202 #0282: si[99].rel_off
644 1204 #0284: si[99].tupo_off
646 1206 #0286: si[99].dom_size
648 1210 #0288: si[100].rel_off
650 1212 #028a: si[100].tupo_off
652 1214 #028c: si[100].dom_size
654 1216 #028e: si[101].rel_off
656 1220 #0290: si[101].tupo_off
658 1222 #0292: si[101].dom_size
660 1224 #0294: si[102].rel_off
662 1226 #0296: si[102].tupo_off
664 1230 #0298: si[102].dom_size
666 1232 #029a: si[103].rel_off
668 1234 #029c: si[103].tupo_off
670 1236 #029e: si[103].dom_size
672 1240 #02a0: si[104].rel_off
674 1242 #02a2: si[104].tupo_off
676 1244 #02a4: si[104].dom_size
678 1246 #02a6: si[105].rel_off
680 1250 #02a8: si[105].tupo_off
682 1252 #02aa: si[105].dom_size
684 1254 #02ac: si[106].rel_off
686 1256 #02ae: si[106].tupo_off
688 1260 #02b0: si[106].dom_size
690 1262 #02b2: si[107].rel_off
692 1264 #02b4: si[107].tupo_off
694 1266 #02b6: si[107].dom_size
696 1270 #02b8: si[108].rel_off
698 1272 #02ba: si[108].tupo_off
700 1274 #02bc: si[108].dom_size
702 1276 #02be: si[109].rel_off
704 1300 #02c0: si[109].tupo_off
706 1302 #02c2: si[109].dom_size
708 1304 #02c4: si[110].rel_off
710 1306 #02c6: si[110].tupo_off
712 1310 #02c8: si[110].dom_size
714 1312 #02ca: si[111].rel_off
716 1314 #02cc: si[111].tupo_off
718 1316 #02ce: si[111].dom_size
720 1320 #02d0: si[112].rel_off
722 1322 #02d2: si[112].tupo_off
724 1324 #02d4: si[112].dom_size
726 1326 #02d6: si[113].rel_off
728 1330 #02d8: si[113].tupo_off
730 1332 #02da: si[113].dom_size
732 1334 #02dc: si[114].rel_off
734 1336 #02de: si[114].tupo_off
736 1340 #02e0: si[114].dom_size
738 1342 #02e2: si[115].rel_off
740 1344 #02e4: si[115].tupo_off
742 1346 #02e6: si[115].dom_size
744 1350 #02e8: si[116].rel_off
746 1352 #02ea: si[116].tupo_off
748 1354 #02ec: si[116].dom_size
750 1356 #02ee: si[117].rel_off
752 1360 #02f0: si[117].tupo_off
754 1362 #02f2: si[117].dom_size
756 1364 #02f4: si[118].rel_off
758 1366 #02f6: si[118].tupo_off
760 1370 #02f8: si[118].dom_size
762 1372 #02fa: si[119].rel_off
764 1374 #02fc: si[119].tupo_off
766 1376 #02fe: si[119].dom_size
768 1400 #0300: si[120].rel_off
770 1402 #0302: si[120].tupo_off
772 1404 #0304: si[120].dom_size
774 1406 #0306: si[121].rel_off
776 1410 #0308: si[121].tupo_off
778 1412 #030a: si[121].dom_size
780 1414 #030c: si[122].rel_off
782 1416 #030e: si[122].tupo_off
784 1420 #0310: si[122].dom_size
786 1422 #0312: si[123].rel_off
788 1424 #0314: si[123].tupo_off
790 1426 #0316: si[123].dom_size
792 1430 #0318: si[124].rel_off
794 1432 #031a: si[124].tupo_off
796 1434 #031c: si[124].dom_size
798 1436 #031e: si[125].rel_off
800 1440 #0320: si[125].tupo_off
802 1442 #0322: si[125].dom_size
804 1444 #0324: si[126].rel_off
806 1446 #0326: si[126].tupo_off
808 1450 #0328: si[126].dom_size
810 1452 #032a: si[127].rel_off
812 1454 #032c: si[127].tupo_off
814 1456 #032e: si[127].dom_size
816 1460 #0330: si[128].rel_off
818 1462 #0332: si[128].tupo_off
820 1464 #0334: si[128].dom_size
822 1466 #0336: si[129].rel_off
824 1470 #0338: si[129].tupo_off
826 1472 #033a: si[129].dom_size
++++++++++ DESC ++++++++++
struct desc == DESC
0 0000 #0000: reldum.relid
12 0014 #000c: reldum.relowner
14 0016 #000e: reldum.relspec
15 0017 #000f: reldum.relindxd
16 0020 #0010: reldum.relsave
20 0024 #0014: reldum.reltups
24 0030 #0018: reldum.relatts
26 0032 #001a: reldum.relwid
28 0034 #001c: reldum.relprim
32 0040 #0020: reldum.relspare
36 0044 #0024: reldum.relstat
40 0050 #0028: relfp
42 0052 #002a: relopn
44 0054 #002c: reltid
48 0060 #0030: reladds
52 0064 #0034: reloff
310 0466 #0136: relfrmt
439 0667 #01b7: relfrml
568 1070 #0238: relxtra
697 1271 #02b9: relgiven
++++++++++ DESCXX ++++++++++
struct descxx == DESCXX
0 0000 #0000: xx_desc.reldum.relid
12 0014 #000c: xx_desc.reldum.relowner
14 0016 #000e: xx_desc.reldum.relspec
15 0017 #000f: xx_desc.reldum.relindxd
16 0020 #0010: xx_desc.reldum.relsave
20 0024 #0014: xx_desc.reldum.reltups
24 0030 #0018: xx_desc.reldum.relatts
26 0032 #001a: xx_desc.reldum.relwid
28 0034 #001c: xx_desc.reldum.relprim
32 0040 #0020: xx_desc.reldum.relspare
36 0044 #0024: xx_desc.reldum.relstat
40 0050 #0028: xx_desc.relfp
42 0052 #002a: xx_desc.relopn
44 0054 #002c: xx_desc.reltid
48 0060 #0030: xx_desc.reladds
52 0064 #0034: xx_desc.reloff
310 0466 #0136: xx_desc.relfrmt
439 0667 #01b7: xx_desc.relfrml
568 1070 #0238: xx_desc.relxtra
697 1271 #02b9: xx_desc.relgiven
828 1474 #033c: xx_next
832 1500 #0340: xx_index
836 1504 #0344: xx_indom
840 1510 #0348: xx_ta
845 1515 #034d: xx_excl
846 1516 #034e: xx_locks
++++++++++ DESXX ++++++++++
struct desxx
0 0000 #0000: cach_relname
4 0004 #0004: cach_desc
8 0010 #0008: cach_alias
++++++++++ INDEX ++++++++++
struct index
0 0000 #0000: irelidp
12 0014 #000c: iownerp
14 0016 #000e: irelidi
26 0032 #001a: irelspeci
27 0033 #001b: idom
++++++++++ INTEGRITY ++++++++++
struct integrity
0 0000 #0000: intrelid
12 0014 #000c: intrelowner
14 0016 #000e: inttree
16 0020 #0010: intdomset
32 0040 #0020: intresvar
++++++++++ LASTOK ++++++++++
struct lastok
0 0000 #0000: toktyp
4 0004 #0004: tok
8 0010 #0008: tokop
++++++++++ LOCKREQ ++++++++++
struct lockreq == LOCKREQ
0 0000 #0000: l_db
4 0004 #0004: l_rel
8 0010 #0008: l_page
12 0014 #000c: l_act
13 0015 #000d: l_mode
14 0016 #000e: l_pid
++++++++++ OPTAB ++++++++++
struct optab
0 0000 #0000: term
4 0004 #0004: token
6 0006 #0006: opcode
++++++++++ OP_NODE ++++++++++
struct op_node == OP_NODE
0 0000 #0000: qt_hdr
12 0014 #000c: opno
++++++++++ OUT_ARG ++++++++++
struct out_arg
0 0000 #0000: c0width
2 0002 #0002: i1width
4 0004 #0004: i2width
6 0006 #0006: i4width
8 0010 #0008: f4width
10 0012 #000a: f8width
12 0014 #000c: f4prec
14 0016 #000e: f8prec
16 0020 #0010: f4style
17 0021 #0011: f8style
18 0022 #0012: linesperpage
20 0024 #0014: coldelim
++++++++++ PIPFRMT ++++++++++
struct pipfrmt
0 0000 #0000: exec_id
1 0001 #0001: func_id
2 0002 #0002: err_id
4 0004 #0004: hdrstat
5 0005 #0005: buf_len
6 0006 #0006: param_id
7 0007 #0007: expansion
8 0010 #0008: pbuf
128 0200 #0080: pbuf_pt
++++++++++ PROTECT ++++++++++
struct protect
0 0000 #0000: prorelid
12 0014 #000c: prorelown
14 0016 #000e: propermid
16 0020 #0010: prouser
18 0022 #0012: proterm
20 0024 #0014: proresvar
21 0025 #0015: proopset
22 0026 #0016: protodbgn
24 0030 #0018: protodend
26 0032 #001a: prodowbgn
27 0033 #001b: prodowend
28 0034 #001c: prodomset
44 0054 #002c: protree
++++++++++ QTREE ++++++++++
struct querytree == QREE
0 0000 #0000: left
4 0004 #0004: right
8 0010 #0008: sym.type
9 0011 #0009: sym.len
10 0012 #000a: sym.aligned
12 0014 #000c: sym.value
++++++++++ REFS ++++++++++
struct refs
0 0000 #0000: refrelid
12 0014 #000c: refowner
14 0016 #000e: refbrelid
26 0032 #001a: refbowner
28 0034 #001c: reftype
++++++++++ RELATION ++++++++++
struct relation
0 0000 #0000: relid
12 0014 #000c: relowner
14 0016 #000e: relspec
15 0017 #000f: relindxd
16 0020 #0010: relsave
20 0024 #0014: reltups
24 0030 #0018: relatts
26 0032 #001a: relwid
28 0034 #001c: relprim
32 0040 #0020: relspare
36 0044 #0024: relstat
++++++++++ RES_NODE ++++++++++
struct res_node == RES_NODE
0 0000 #0000: qt_hdr
12 0014 #000c: resno
++++++++++ RETCODE ++++++++++
struct retcode
0 0000 #0000: rc_tupcount
4 0004 #0004: rc_status
6 0006 #0006: rc_siteid
++++++++++ ROOT_NODE ++++++++++
struct root_node == ROOT_NODE
0 0000 #0000: qt_hdr
12 0014 #000c: tvarc
13 0015 #000d: lvarc
14 0016 #000e: lvarm
16 0020 #0010: rvarm
18 0022 #0012: rootuser
++++++++++ SI_DOMS ++++++++++
struct si_doms
0 0000 #0000: rel_off
2 0002 #0002: tupo_off
4 0004 #0004: dom_size
++++++++++ SPECIAL ++++++++++
struct special
0 0000 #0000: sconst
2 0002 #0002: bgncmnt
4 0004 #0004: endcmnt
6 0006 #0006: i2const
8 0010 #0008: i4const
10 0012 #000a: f4const
12 0014 #000c: f8const
14 0016 #000e: name
++++++++++ SRCID ++++++++++
struct srcid == SRCID
0 0000 #0000: sym_hdr
4 0004 #0004: srcvar
6 0006 #0006: srcname
18 0022 #0012: srcown
20 0024 #0014: srcstat
++++++++++ SVAR_NODE ++++++++++
struct svar_node == SVAR_NODE
0 0000 #0000: sym_hdr
4 0004 #0004: vattno
6 0006 #0006: vtype
7 0007 #0007: vlen
8 0010 #0008: vpoint
++++++++++ SYMBOL ++++++++++
struct symbol == SYMBOL
0 0000 #0000: type
1 0001 #0001: len
2 0002 #0002: aligned
4 0004 #0004: value
++++++++++ TREE ++++++++++
struct tree
0 0000 #0000: treerelid
12 0014 #000c: treeowner
14 0016 #000e: treeid
16 0020 #0010: treeseq
18 0022 #0012: treetype
19 0023 #0013: treexxxx
20 0024 #0014: treetree
++++++++++ TUP_ID ++++++++++
struct tup_id
0 0000 #0000: line_id
1 0001 #0001: pg2
2 0002 #0002: pg1
3 0003 #0003: pg0
++++++++++ VAR_NODE ++++++++++
struct var_node == VAR_NODE
0 0000 #0000: qt_hdr
12 0014 #000c: varno
13 0015 #000d: attno
14 0016 #000e: frmt
15 0017 #000f: frml
16 0020 #0010: valptr

30
WEGA/contrib/ingres/dbs/src/struct/SVAR_NODE.c Normal file
View File

@ -0,0 +1,30 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register SVAR_NODE *d;
register int i;
SVAR_NODE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct svar_node == SVAR_NODE [h/tree.h]\n");
d = &desc;
off(d->sym_hdr);
out("sym_hdr (char [SYM_HDR_SIZ])");
off(&d->vattno);
out("vattno (short)");
off(&d->vtype);
out("vtype (char)");
off(&d->vlen);
out("vlen (char)");
off(&d->vpoint);
out("vpoint (short *)");
fflush(stdout);
}

30
WEGA/contrib/ingres/dbs/src/struct/SYMBOL.c Normal file
View File

@ -0,0 +1,30 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register SYMBOL *d;
register int i;
SYMBOL desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct symbol == SYMBOL [h/tree.h]\n");
d = &desc;
off(&d->type);
out("type (char)");
off(&d->len);
out("len (char)");
# ifdef BIT_32
off(&d->aligned);
out("aligned (short)");
# endif
off(d->value);
out("value (short [1])");
fflush(stdout);
}

34
WEGA/contrib/ingres/dbs/src/struct/TREE.c Normal file
View File

@ -0,0 +1,34 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/catalog.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct tree *d;
register int i;
struct tree desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct tree [h/tree.h]\n");
d = &desc;
off(d->treerelid);
out("treerelid (char [MAXNAME])");
off(d->treeowner);
out("treeowner (char [2])");
off(&d->treeid);
out("treeid (short)");
off(&d->treeseq);
out("treeseq (short)");
off(&d->treetype);
out("treetype (char)");
off(&d->treexxxx);
out("treexxxx (char)");
off(d->treetree);
out("treetree (char [100])");
fflush(stdout);
}

32
WEGA/contrib/ingres/dbs/src/struct/TUP_HDR.c Normal file
View File

@ -0,0 +1,32 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/access.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct tup_hdr *d;
register int i;
struct tup_hdr desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct tup_hdr [h/access.h]\n");
d = &desc;
off(&d->tup_ptr);
out("tup_ptr (char *)");
off(&d->tup_end);
out("tup_end (char *)");
off(&d->tup_fd);
out("tup_fd (int)");
off(&d->tup_no);
out("tup_no (short)");
off(&d->tup_len);
out("tup_len (short)");
off(d->tup_buf);
out("tup_buf (char [TUP_BUF_SIZ])");
fflush(stdout);
}

61
WEGA/contrib/ingres/dbs/src/struct/TUP_ID.c Normal file
View File

@ -0,0 +1,61 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/catalog.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register struct tup_id *d;
register int i;
struct tup_id desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct tup_id [h/ing_db.h]\n");
d = &desc;
# ifdef REV_BYTES
# ifdef REV_WORDS
off(&d->line_id);
out("line_id (char)");
off(&d->pg2);
out("pg2 (char)");
off(&d->pg1);
out("pg1 (char)");
off(&d->pg0);
out("pg0 (char)");
# else
off(&d->pg1);
out("pg1 (char)");
off(&d->pg0);
out("pg0 (char)");
off(&d->line_id);
out("line_id (char)");
off(&d->pg2);
out("pg2 (char)");
# endif
# else
# ifdef REV_WORDS
off(&d->pg2);
out("pg2 (char)");
off(&d->line_id);
out("line_id (char)");
off(&d->pg0);
out("pg0 (char)");
off(&d->pg1);
out("pg1 (char)");
# else
off(&d->pg0);
out("pg0 (char)");
off(&d->pg1);
out("pg1 (char)");
off(&d->pg2);
out("pg2 (char)");
off(&d->line_id);
out("line_id (char)");
# endif
# endif
fflush(stdout);
}

32
WEGA/contrib/ingres/dbs/src/struct/VAR_NODE.c Normal file
View File

@ -0,0 +1,32 @@
# include <stdio.h>
# include "../conf/conf.h"
# include "../h/ing_db.h"
# include "../h/tree.h"
# define off(x) i = ((char *) x) - ((char *) d)
# define out(arg) printf("%4d %06o #%04x:\t%s\n", i, i, i, arg)
main()
{
register VAR_NODE *d;
register int i;
VAR_NODE desc;
char buf[BUFSIZ];
setbuf(stdout, buf);
printf("struct var_node == VAR_NODE [h/tree.h]\n");
d = &desc;
off(d->qt_hdr);
out("qt_hdr (char [QT_HDR_SIZ])");
off(&d->varno);
out("varno (char)");
off(&d->attno);
out("attno (char)");
off(&d->frmt);
out("frmt (char)");
off(&d->frml);
out("frml (char)");
off(&d->valptr);
out("valptr (char *)");
fflush(stdout);
}