From 9626b72867ef4e80257ad8e796c4b7dac4028d96 Mon Sep 17 00:00:00 2001 From: Oliver Lehmann Date: Fri, 10 Feb 1989 10:54:47 +0000 Subject: [PATCH] ING_DB --- WEGA/contrib/ingres/dbs/src/struct/ACCBUF.c | 42 + .../ingres/dbs/src/struct/ACCESSPARAM.c | 26 + WEGA/contrib/ingres/dbs/src/struct/ADMIN.c | 126 ++ WEGA/contrib/ingres/dbs/src/struct/ADMINHDR.c | 24 + WEGA/contrib/ingres/dbs/src/struct/AOP_NODE.c | 28 + .../contrib/ingres/dbs/src/struct/ATTRIBUTE.c | 35 + WEGA/contrib/ingres/dbs/src/struct/BATCHBUF.c | 25 + WEGA/contrib/ingres/dbs/src/struct/BATCHHD.c | 55 + WEGA/contrib/ingres/dbs/src/struct/C.c | 1108 +++++++++++++++++ WEGA/contrib/ingres/dbs/src/struct/DESC.adb | 20 + WEGA/contrib/ingres/dbs/src/struct/DESC.c | 67 + WEGA/contrib/ingres/dbs/src/struct/DESCXX.adb | 26 + WEGA/contrib/ingres/dbs/src/struct/DESCXX.c | 82 ++ WEGA/contrib/ingres/dbs/src/struct/DESXX.c | 26 + WEGA/contrib/ingres/dbs/src/struct/INDEX.c | 30 + .../contrib/ingres/dbs/src/struct/INTEGRITY.c | 37 + WEGA/contrib/ingres/dbs/src/struct/LASTOK.c | 28 + WEGA/contrib/ingres/dbs/src/struct/LOCKREQ.c | 31 + WEGA/contrib/ingres/dbs/src/struct/OFFEN | 1 + WEGA/contrib/ingres/dbs/src/struct/OPTAB.c | 28 + WEGA/contrib/ingres/dbs/src/struct/OP_NODE.c | 24 + WEGA/contrib/ingres/dbs/src/struct/OUT_ARG.c | 50 + WEGA/contrib/ingres/dbs/src/struct/PGTUPLE.c | 63 + WEGA/contrib/ingres/dbs/src/struct/PIPFRMT.c | 35 + WEGA/contrib/ingres/dbs/src/struct/PROTECT.c | 46 + WEGA/contrib/ingres/dbs/src/struct/QTREE.c | 36 + WEGA/contrib/ingres/dbs/src/struct/REFS.c | 30 + WEGA/contrib/ingres/dbs/src/struct/RELATION.c | 47 + WEGA/contrib/ingres/dbs/src/struct/RES_NODE.c | 24 + WEGA/contrib/ingres/dbs/src/struct/RETCODE.c | 26 + .../contrib/ingres/dbs/src/struct/ROOT_NODE.c | 32 + WEGA/contrib/ingres/dbs/src/struct/S.c | 736 +++++++++++ WEGA/contrib/ingres/dbs/src/struct/SI_DOMS.c | 27 + WEGA/contrib/ingres/dbs/src/struct/SPECIAL.c | 40 + WEGA/contrib/ingres/dbs/src/struct/SRCID.c | 30 + .../contrib/ingres/dbs/src/struct/STRUCTS.VAX | 824 ++++++++++++ .../contrib/ingres/dbs/src/struct/SVAR_NODE.c | 30 + WEGA/contrib/ingres/dbs/src/struct/SYMBOL.c | 30 + WEGA/contrib/ingres/dbs/src/struct/TREE.c | 34 + WEGA/contrib/ingres/dbs/src/struct/TUP_HDR.c | 32 + WEGA/contrib/ingres/dbs/src/struct/TUP_ID.c | 61 + WEGA/contrib/ingres/dbs/src/struct/VAR_NODE.c | 32 + 42 files changed, 4134 insertions(+) create mode 100644 WEGA/contrib/ingres/dbs/src/struct/ACCBUF.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/ACCESSPARAM.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/ADMIN.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/ADMINHDR.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/AOP_NODE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/ATTRIBUTE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/BATCHBUF.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/BATCHHD.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/C.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/DESC.adb create mode 100644 WEGA/contrib/ingres/dbs/src/struct/DESC.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/DESCXX.adb create mode 100644 WEGA/contrib/ingres/dbs/src/struct/DESCXX.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/DESXX.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/INDEX.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/INTEGRITY.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/LASTOK.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/LOCKREQ.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/OFFEN create mode 100644 WEGA/contrib/ingres/dbs/src/struct/OPTAB.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/OP_NODE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/OUT_ARG.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/PGTUPLE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/PIPFRMT.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/PROTECT.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/QTREE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/REFS.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/RELATION.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/RES_NODE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/RETCODE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/ROOT_NODE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/S.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/SI_DOMS.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/SPECIAL.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/SRCID.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/STRUCTS.VAX create mode 100644 WEGA/contrib/ingres/dbs/src/struct/SVAR_NODE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/SYMBOL.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/TREE.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/TUP_HDR.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/TUP_ID.c create mode 100644 WEGA/contrib/ingres/dbs/src/struct/VAR_NODE.c diff --git a/WEGA/contrib/ingres/dbs/src/struct/ACCBUF.c b/WEGA/contrib/ingres/dbs/src/struct/ACCBUF.c new file mode 100644 index 0000000..5631cf1 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/ACCBUF.c @@ -0,0 +1,42 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/ACCESSPARAM.c b/WEGA/contrib/ingres/dbs/src/struct/ACCESSPARAM.c new file mode 100644 index 0000000..503460c --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/ACCESSPARAM.c @@ -0,0 +1,26 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/ADMIN.c b/WEGA/contrib/ingres/dbs/src/struct/ADMIN.c new file mode 100644 index 0000000..900ccb8 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/ADMIN.c @@ -0,0 +1,126 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/ADMINHDR.c b/WEGA/contrib/ingres/dbs/src/struct/ADMINHDR.c new file mode 100644 index 0000000..f42c587 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/ADMINHDR.c @@ -0,0 +1,24 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/AOP_NODE.c b/WEGA/contrib/ingres/dbs/src/struct/AOP_NODE.c new file mode 100644 index 0000000..192c882 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/AOP_NODE.c @@ -0,0 +1,28 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/ATTRIBUTE.c b/WEGA/contrib/ingres/dbs/src/struct/ATTRIBUTE.c new file mode 100644 index 0000000..16a26a4 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/ATTRIBUTE.c @@ -0,0 +1,35 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/BATCHBUF.c b/WEGA/contrib/ingres/dbs/src/struct/BATCHBUF.c new file mode 100644 index 0000000..dba3bff --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/BATCHBUF.c @@ -0,0 +1,25 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/BATCHHD.c b/WEGA/contrib/ingres/dbs/src/struct/BATCHHD.c new file mode 100644 index 0000000..dda5eda --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/BATCHHD.c @@ -0,0 +1,55 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/C.c b/WEGA/contrib/ingres/dbs/src/struct/C.c new file mode 100644 index 0000000..5946a99 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/C.c @@ -0,0 +1,1108 @@ +# include +# include "../conf/gen.h" +# include "../h/ing_db.h" +# include "../h/aux.h" +# include "../h/catalog.h" +# include "../h/access.h" +# include "../h/batch.h" +# include "../h/pipes.h" +# include "../h/lock.h" +# include "../h/scanner.h" +# include "../h/version.h" +# include "../h/unix.h" + +struct tab_of_op +{ + int no_of_op; + char *name_of_op; +}; + +struct tab_of_op Tab_of_op[] = +{ + 1, "ALPHA", /* scanner.h */ + 2, "AMATTR_ERR", /* access.h */ + 3, "AMCLOSE_ERR", /* access.h */ + 4, "AMFIND_ERR", /* access.h */ + 5, "AMINVL_ERR", /* access.h */ + 6, "AMNOATTS_ERR", /* access.h */ + 7, "AMNOFILE_ERR", /* access.h */ + 8, "AMOPNVIEW_ERR", /* access.h */ + 9, "AMREAD_ERR", /* access.h */ + 10, "AMREL_ERR", /* access.h */ + 11, "AMSEEK_ERR", /* access.h */ + 12, "AMWRITE_ERR", /* access.h */ + 13, "ATTID", /* ing_db.h */ + 14, "ATTNAME", /* ing_db.h */ + 15, "ATTOWNER", /* ing_db.h */ + 16, "ATTRELID", /* ing_db.h */ + 17, "A_ABT", /* lock.h */ + 18, "A_DBCONCUR", /* access.h */ + 19, "A_NEWFMT", /* access.h */ + 20, "A_QRYMOD", /* access.h */ + 21, "A_RLS1", /* lock.h */ + 22, "A_RLSA", /* lock.h */ + 23, "A_RTN", /* lock.h */ + 24, "A_SLP", /* lock.h */ + 25, "BADOP", /* scanner.h */ + 26, "BATCHSIZE", /* batch.h */ + 27, "BLKSIZ", /* access.h */ + 28, "BUF_DIRECT", /* access.h */ + 29, "BUF_DIRTY", /* access.h */ + 30, "BUF_LOCKED", /* access.h */ + 31, "CNTRL", /* scanner.h */ + 32, "CNTRLCHR", /* scanner.h */ + 33, "COMMTERM", /* scanner.h */ + 34, "COREBUFSIZE", /* access.h */ + 35, "CS_LOCK", /* lock.h */ + 36, "CVAR_F8", /* scanner.h */ + 37, "CVAR_I2", /* scanner.h */ + 38, "CVAR_I4", /* scanner.h */ + 39, "CVAR_S", /* scanner.h */ + 40, "DB_LOCK", /* lock.h */ + 41, "ERRDELIM", /* conf/gen.h */ + 42, "ERR_STAT", /* pipes.h */ + 43, "EXACTKEY", /* ing_db.h */ + 44, "EXEC_DBU", /* aux.h */ + 45, "EXEC_DECOMP", /* aux.h */ + 46, "EXEC_ERROR", /* aux.h */ + 47, "EXEC_OVQP", /* aux.h */ + 48, "EXEC_PARSER", /* aux.h */ + 49, "EXEC_QRYMOD", /* aux.h */ + 50, "FALSE", /* ing_db.h */ + 51, "FCONSTERR", /* scanner.h */ + 52, "FILEMODE", /* aux.h */ + 53, "FULLKEY", /* ing_db.h */ + 54, "GOVAL", /* scanner.h */ + 55, "HDRSIZ", /* pipes.h */ + 56, "HRANGEKEY", /* ing_db.h */ + 57, "I1MASK", /* ing_db.h */ + 58, "IDSIZE", /* batch.h */ + 59, "ING_RSIZE", /* lock.h */ + 60, "ING_SSIZE", /* lock.h */ + 61, "ING_UID", /* conf/conf.h */ + 62, "ING_WSIZE", /* lock.h */ + 63, "INTRELID", /* catalog.h */ + 64, "INTRELOWNER", /* catalog.h */ + 65, "INTTREE", /* catalog.h */ + 66, "IOWNERP", /* catalog.h */ + 67, "IRELIDI", /* catalog.h */ + 68, "IRELIDP", /* catalog.h */ + 69, "LAST_STAT", /* pipes.h */ + 70, "LOCKS", /* conf/conf.h */ + 71, "LOG2WORDSIZE", /* aux.h */ + 72, "LRANGEKEY", /* ing_db.h */ + 73, "MACHINE", /* conf/conf.h */ + 74, "MAXAGG", /* ing_db.h */ + 75, "MAXDOM", /* ing_db.h */ + 76, "MAXFIELD", /* aux.h */ + 77, "MAXFILES", /* unix.h */ + 78, "MAXKEYS", /* ing_db.h */ + 79, "MAXLINE", /* aux.h */ + 80, "MAXNAME", /* ing_db.h */ + 81, "MAXPARMS", /* ing_db.h */ + 82, "MAXSTRING", /* scanner.h */ + 83, "MAXTID", /* access.h */ + 84, "MAXTUP", /* ing_db.h */ + 85, "MAXVAR", /* ing_db.h */ + 86, "MERGESIZE", /* access.h */ + 87, "MINTUP", /* ing_db.h */ + 88, "MODTID", /* access.h */ + 89, "MOD_DATE", /* version.h */ + 90, "M_BTREE", /* access.h */ + 91, "M_DB", /* lock.h */ + 92, "M_ERROR", /* lock.h */ + 93, "M_EXCL", /* lock.h */ + 94, "M_HASH", /* access.h */ + 95, "M_HEAP", /* access.h */ + 96, "M_ISAM", /* access.h */ + 97, "M_MODE", /* lock.h */ + 98, "M_ON", /* lock.h */ + 99, "M_REL", /* lock.h */ + 100, "M_SHARE", /* lock.h */ + 101, "M_TA", /* lock.h */ + 102, "M_TE", /* lock.h */ + 103, "M_TRUNC", /* access.h */ + 104, "NACCBUFS", /* access.h */ + 105, "NAMELONG", /* scanner.h */ + 106, "NOKEY", /* ing_db.h */ + 107, "NORM_STAT", /* pipes.h */ + 108, "NO_REL", /* lock.h */ + 109, "NULL", /* ing_db.h */ + 110, "NUMBR", /* scanner.h */ + 111, "NUMBUFOFLO", /* scanner.h */ + 112, "OPATR", /* scanner.h */ + 113, "PBUFSIZ", /* pipes.h */ + 114, "PGBLKS", /* conf/conf.h */ + 115, "PGHDR", /* access.h */ + 116, "PGPTRSIZ", /* access.h */ + 117, "PGSIZE", /* access.h */ + 118, "PROPERMID", /* catalog.h */ + 119, "PRORELID", /* catalog.h */ + 120, "PRORELOWN", /* catalog.h */ + 121, "PROTERM", /* catalog.h */ + 122, "PROTREE", /* catalog.h */ + 123, "PRO_AGGR", /* catalog.h */ + 124, "PRO_APP", /* catalog.h */ + 125, "PRO_DEL", /* catalog.h */ + 126, "PRO_REPL", /* catalog.h */ + 127, "PRO_RETR", /* catalog.h */ + 128, "PRO_TEST", /* catalog.h */ + 129, "PUNCT", /* scanner.h */ + 130, "P_END", /* pipes.h */ + 131, "P_EXECID", /* pipes.h */ + 132, "P_FLUSH", /* pipes.h */ + 133, "P_FUNCID", /* pipes.h */ + 134, "P_INT", /* pipes.h */ + 135, "P_NORM", /* pipes.h */ + 136, "P_PARAM", /* pipes.h */ + 137, "P_PRIME", /* pipes.h */ + 138, "P_SYNC", /* pipes.h */ + 139, "P_WRITE", /* pipes.h */ + 140, "REFOWNER", /* catalog.h */ + 141, "REFRELID", /* catalog.h */ + 142, "REFTYPE", /* catalog.h */ + 143, "RELID", /* ing_db.h */ + 144, "RELOWNER", /* ing_db.h */ + 145, "REL_DATE", /* version.h */ + 146, "REL_LOCK", /* lock.h */ + 147, "SBUFOFLO", /* scanner.h */ + 148, "SBUFSIZ", /* scanner.h */ + 149, "SCANTID", /* access.h */ + 150, "SECBASE", /* catalog.h */ + 151, "SECINDEX", /* catalog.h */ + 152, "STACKSIZ", /* ing_db.h */ + 153, "STRLONG", /* scanner.h */ + 154, "STRTERM", /* scanner.h */ + 155, "SYMERR", /* scanner.h */ + 156, "SYNC_STAT", /* pipes.h */ + 157, "S_BINARY", /* aux.h */ + 158, "S_CATALOG", /* aux.h */ + 159, "S_CONCUR", /* aux.h */ + 160, "S_DISCOPY", /* aux.h */ + 161, "S_DISCRIT", /* aux.h */ + 162, "S_DISTRIBUTED", /* aux.h */ + 163, "S_INDEX", /* aux.h */ + 164, "S_INTEG", /* aux.h */ + 165, "S_NOUPDT", /* aux.h */ + 166, "S_PROTALL", /* aux.h */ + 167, "S_PROTRET", /* aux.h */ + 168, "S_PROTUPS", /* aux.h */ + 169, "S_VBASE", /* aux.h */ + 170, "S_VIEW", /* aux.h */ + 171, "TREEID", /* catalog.h */ + 172, "TREEOWNER", /* catalog.h */ + 173, "TREERELID", /* catalog.h */ + 174, "TREESEQ", /* catalog.h */ + 175, "TREETYPE", /* catalog.h */ + 176, "TRUE", /* ing_db.h */ + 177, "TUP_BUF_SIZ", /* access.h */ + 178, "UF_DBLIST", /* aux.h */ + 179, "UF_FLAGS", /* aux.h */ + 180, "UF_GID", /* aux.h */ + 181, "UF_IFILE", /* aux.h */ + 182, "UF_NAME", /* aux.h */ + 183, "UF_NFIELDS", /* aux.h */ + 184, "UF_PTAB", /* aux.h */ + 185, "UF_STAT", /* aux.h */ + 186, "UF_UCODE", /* aux.h */ + 187, "UF_UID", /* aux.h */ + 188, "USERING_DB", /* unix.h */ + 189, "USE_LOCK", /* lock.h */ + 190, "U_APROCTAB", /* aux.h */ + 191, "U_CREATDB", /* aux.h */ + 192, "U_DRCTUPDT", /* aux.h */ + 193, "U_EPROCTAB", /* aux.h */ + 194, "U_QRYMODOFF", /* aux.h */ + 195, "U_SUPER", /* aux.h */ + 196, "U_TRACE", /* aux.h */ + 197, "U_UPSYSCAT", /* aux.h */ + 198, "VERSION", /* version.h */ + 199, "WORDSIZE", /* aux.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/scanner.h\tALPHA\t\t%6d\n", ALPHA); + break; + + case 2: + printf("h/access.h\tAMATTR_ERR\t%6d\n", AMATTR_ERR); + break; + + case 3: + printf("h/access.h\tAMCLOSE_ERR\t%6d\n", AMCLOSE_ERR); + break; + + case 4: + printf("h/access.h\tAMFIND_ERR\t%6d\n", AMFIND_ERR); + break; + + case 5: + printf("h/access.h\tAMINVL_ERR\t%6d\n", AMINVL_ERR); + break; + + case 6: + printf("h/access.h\tAMNOATTS_ERR\t%6d\n", AMNOATTS_ERR); + break; + + case 7: + printf("h/access.h\tAMNOFILE_ERR\t%6d\n", AMNOFILE_ERR); + break; + + case 8: + printf("h/access.h\tAMOPNVIEW_ERR\t%6d\n", AMOPNVIEW_ERR); + break; + + case 9: + printf("h/access.h\tAMREAD_ERR\t%6d\n", AMREAD_ERR); + break; + + case 10: + printf("h/access.h\tAMREL_ERR\t%6d\n", AMREL_ERR); + break; + + case 11: + printf("h/access.h\tAMSEEK_ERR\t%6d\n", AMSEEK_ERR); + break; + + case 12: + printf("h/access.h\tAMWRITE_ERR\t%6d\n", AMWRITE_ERR); + break; + + case 13: + printf("h/ing_db.h\tATTID\t\t%6d\n", ATTID); + break; + + case 14: + printf("h/ing_db.h\tATTNAME\t\t%6d\n", ATTNAME); + break; + + case 15: + printf("h/ing_db.h\tATTOWNER\t%6d\n", ATTOWNER); + break; + + case 16: + printf("h/ing_db.h\tATTRELID\t%6d\n", ATTRELID); + break; + + case 17: + printf("h/lock.h\tA_ABT\t\t%6d\n", A_ABT); + break; + + case 18: + printf("h/access.h\tA_DBCONCUR\t%06o\n", A_DBCONCUR); + break; + + case 19: + printf("h/access.h\tA_NEWFMT\t%06o\n", A_NEWFMT); + break; + + case 20: + printf("h/access.h\tA_QRYMOD\t%06o\n", A_QRYMOD); + break; + + case 21: + printf("h/lock.h\tA_RLS1\t\t%6d\n", A_RLS1); + break; + + case 22: + printf("h/lock.h\tA_RLSA\t\t%6d\n", A_RLSA); + break; + + case 23: + printf("h/lock.h\tA_RTN\t\t%6d\n", A_RTN); + break; + + case 24: + printf("h/lock.h\tA_SLP\t\t%6d\n", A_SLP); + break; + + case 25: + printf("h/scanner.h\tBADOP\t\t%6d\n", BADOP); + break; + + case 26: + printf("h/batch.h\tBATCHSIZE\t%6d\n", BATCHSIZE); + break; + + case 27: + printf("h/access.h\tBLKSIZ\t\t%6d\n", BLKSIZ); + break; + + case 28: + printf("h/access.h\tBUF_DIRECT\t%06o\n", BUF_DIRECT); + break; + + case 29: + printf("h/access.h\tBUF_DIRTY\t%06o\n", BUF_DIRTY); + break; + + case 30: + printf("h/access.h\tBUF_LOCKED\t%06o\n", BUF_LOCKED); + break; + + case 31: + printf("h/scanner.h\tCNTRL\t\t%6d\n", CNTRL); + break; + + case 32: + printf("h/scanner.h\tCNTRLCHR\t%6d\n", CNTRLCHR); + break; + + case 33: + printf("h/scanner.h\tCOMMTERM\t%6d\n", COMMTERM); + break; + + case 34: + printf("h/access.h\tCOREBUFSIZE\t%6u\n", COREBUFSIZE); + break; + + case 35: + printf("h/lock.h\tCS_LOCK\t\t%6ld\n", CS_LOCK); + break; + + case 36: + printf("h/scanner.h\tCVAR_F8\t\t%06o\n", CVAR_F8); + break; + + case 37: + printf("h/scanner.h\tCVAR_I2\t\t%06o\n", CVAR_I2); + break; + + case 38: + printf("h/scanner.h\tCVAR_I4\t\t%06o\n", CVAR_I4); + break; + + case 39: + printf("h/scanner.h\tCVAR_S\t\t%06o\n", CVAR_S); + break; + + case 40: + printf("h/lock.h\tDB_LOCK\t\t%6ld\n", DB_LOCK); + break; + + case 41: + printf("conf/gen.h\tERRDELIM\t %c\n", ERRDELIM); + break; + + case 42: + printf("h/pipes.h\tERR_STAT\t%6d\n", ERR_STAT); + break; + + case 43: + printf("h/ing_db.h\tEXACTKEY\t%6d\n", EXACTKEY); + break; + + case 44: + printf("h/aux.h\t\tEXEC_DBU\t %c\n", EXEC_DBU); + break; + + case 45: + printf("h/aux.h\t\tEXEC_DECOMP\t %c\n", EXEC_DECOMP); + break; + + case 46: + printf("h/aux.h\t\tEXEC_ERROR\t %c\n", EXEC_ERROR); + break; + + case 47: + printf("h/aux.h\t\tEXEC_OVQP\t %c\n", EXEC_OVQP); + break; + + case 48: + printf("h/aux.h\t\tEXEC_PARSER\t %c\n", EXEC_PARSER); + break; + + case 49: + printf("h/aux.h\t\tEXEC_QRYMOD\t %c\n", EXEC_QRYMOD); + break; + + case 50: + printf("h/ing_db.h\tFALSE\t\t%6d\n", FALSE); + break; + + case 51: + printf("h/scanner.h\tFCONSTERR\t%6d\n", FCONSTERR); + break; + + case 52: + printf("h/aux.h\t\tFILEMODE\t%6d\n", FILEMODE); + break; + + case 53: + printf("h/ing_db.h\tFULLKEY\t\t%6d\n", FULLKEY); + break; + + case 54: + printf("h/scanner.h\tGOVAL\t\t%6d\n", GOVAL); + break; + + case 55: + printf("h/pipes.h\tHDRSIZ\t\t%6d\n", HDRSIZ); + break; + + case 56: + printf("h/ing_db.h\tHRANGEKEY\t%6d\n", HRANGEKEY); + break; + + case 57: + printf("h/ing_db.h\tI1MASK\t\t%06o\n", I1MASK); + break; + + case 58: + printf("h/batch.h\tIDSIZE\t\t%6d\n", IDSIZE); + break; + + case 59: + printf("h/lock.h\tING_RSIZE\t%6d\n", ING_RSIZE); + break; + + case 60: + printf("h/lock.h\tING_SSIZE\t%6d\n", ING_SSIZE); + break; + + case 61: + printf("conf/conf.h\tING_UID\t\t%6d\n", ING_UID); + break; + + case 62: + printf("h/lock.h\tING_WSIZE\t%6d\n", ING_WSIZE); + break; + + case 63: + printf("h/catalog.h\tINTRELID\t%6d\n", INTRELID); + break; + + case 64: + printf("h/catalog.h\tINTRELOWNER\t%6d\n", INTRELOWNER); + break; + + case 65: + printf("h/catalog.h\tINTTREE\t\t%6d\n", INTTREE); + break; + + case 66: + printf("h/catalog.h\tIOWNERP\t\t%6d\n", IOWNERP); + break; + + case 67: + printf("h/catalog.h\tIRELIDI\t\t%6d\n", IRELIDI); + break; + + case 68: + printf("h/catalog.h\tIRELIDP\t\t%6d\n", IRELIDP); + break; + + case 69: + printf("h/pipes.h\tLAST_STAT\t%6d\n", LAST_STAT); + break; + + case 70: + printf("conf/conf.h\tLOCKS\t\t%6d\n", LOCKS); + break; + + case 71: + printf("h/aux.h\t\tLOG2WORDSIZE\t%6d\n", LOG2WORDSIZE); + break; + + case 72: + printf("h/ing_db.h\tLRANGEKEY\t%6d\n", LRANGEKEY); + break; + + case 73: + printf("conf/conf.h\tMACHINE\t\t%s\n", MACHINE); + break; + + case 74: + printf("h/ing_db.h\tMAXAGG\t\t%6d\n", MAXAGG); + break; + + case 75: + printf("h/ing_db.h\tMAXDOM\t\t%6d\n", MAXDOM); + break; + + case 76: + printf("h/aux.h\t\tMAXFIELD\t%6d\n", MAXFIELD); + break; + + case 77: + printf("h/unix.h\tMAXFILES\t%6d\n", MAXFILES); + break; + + case 78: + printf("h/ing_db.h\tMAXKEYS\t\t%6d\n", MAXKEYS); + break; + + case 79: + printf("h/aux.h\t\tMAXLINE\t\t%6d\n", MAXLINE); + break; + + case 80: + printf("h/ing_db.h\tMAXNAME\t\t%6d\n", MAXNAME); + break; + + case 81: + printf("h/ing_db.h\tMAXPARMS\t%6d\n", MAXPARMS); + break; + + case 82: + printf("h/scanner.h\tMAXSTRING\t%6d\n", MAXSTRING); + break; + + case 83: + printf("h/access.h\tMAXTID\t\t%6d\n", MAXTID); + break; + + case 84: + printf("h/ing_db.h\tMAXTUP\t\t%6d\n", MAXTUP); + break; + + case 85: + printf("h/ing_db.h\tMAXVAR\t\t%6d\n", MAXVAR); + break; + + case 86: + printf("h/access.h\tMERGESIZE\t%6d\n", MERGESIZE); + break; + + case 87: + printf("h/ing_db.h\tMINTUP\t\t%6d\n", MINTUP); + break; + + case 88: + printf("h/access.h\tMODTID\t\t%6d\n", MODTID); + break; + + case 89: + printf("h/version.h\tMOD_DATE\t%s\n", MOD_DATE); + break; + + case 90: + printf("h/access.h\tM_BTREE\t\t%6d\n", M_BTREE); + break; + + case 91: + printf("h/lock.h\tM_DB\t\t%06o\n", M_DB); + break; + + case 92: + printf("h/lock.h\tM_ERROR\t\t%06o\n", M_ERROR); + break; + + case 93: + printf("h/lock.h\tM_EXCL\t\t%06o\n", M_EXCL); + break; + + case 94: + printf("h/access.h\tM_HASH\t\t%6d\n", M_HASH); + break; + + case 95: + printf("h/access.h\tM_HEAP\t\t%6d\n", M_HEAP); + break; + + case 96: + printf("h/access.h\tM_ISAM\t\t%6d\n", M_ISAM); + break; + + case 97: + printf("h/lock.h\tM_MODE\t\t%06o\n", M_MODE); + break; + + case 98: + printf("h/lock.h\tM_ON\t\t%06o\n", M_ON); + break; + + case 99: + printf("h/lock.h\tM_REL\t\t%06o\n", M_REL); + break; + + case 100: + printf("h/lock.h\tM_SHARE\t\t%06o\n", M_SHARE); + break; + + case 101: + printf("h/lock.h\tM_TA\t\t%06o\n", M_TA); + break; + + case 102: + printf("h/lock.h\tM_TE\t\t%06o\n", M_TE); + break; + + case 103: + printf("h/access.h\tM_TRUNC\t\t%6d\n", M_TRUNC); + break; + + case 104: + printf("h/access.h\tNACCBUFS\t%6d\n", NACCBUFS); + break; + + case 105: + printf("h/scanner.h\tNAMELONG\t%6d\n", NAMELONG); + break; + + case 106: + printf("h/ing_db.h\tNOKEY\t\t%6d\n", NOKEY); + break; + + case 107: + printf("h/pipes.h\tNORM_STAT\t%6d\n", NORM_STAT); + break; + + case 108: + printf("h/lock.h\tNO_REL\t\t%6ld\n", NO_REL); + break; + + case 109: + printf("h/ing_db.h\tNULL\t\t%6d\n", NULL); + break; + + case 110: + printf("h/scanner.h\tNUMBR\t\t%6d\n", NUMBR); + break; + + case 111: + printf("h/scanner.h\tNUMBUFOFLO\t%6d\n", NUMBUFOFLO); + break; + + case 112: + printf("h/scanner.h\tOPATR\t\t%6d\n", OPATR); + break; + + case 113: + printf("h/pipes.h\tPBUFSIZ\t\t%6d\n", PBUFSIZ); + break; + + case 114: + printf("conf/conf.h\tPGBLKS\t\t%6d\n", PGBLKS); + break; + + case 115: + printf("h/access.h\tPGHDR\t\t%6d\n", PGHDR); + break; + + case 116: + printf("h/access.h\tPGPTRSIZ\t%6d\n", PGPTRSIZ); + break; + + case 117: + printf("h/access.h\tPGSIZE\t\t%6d\n", PGSIZE); + break; + + case 118: + printf("h/catalog.h\tPROPERMID\t%6d\n", PROPERMID); + break; + + case 119: + printf("h/catalog.h\tPRORELID\t%6d\n", PRORELID); + break; + + case 120: + printf("h/catalog.h\tPRORELOWN\t%6d\n", PRORELOWN); + break; + + case 121: + printf("h/catalog.h\tPROTERM\t\t%6d\n", PROTERM); + break; + + case 122: + printf("h/catalog.h\tPROTREE\t\t%6d\n", PROTREE); + break; + + case 123: + printf("h/catalog.h\tPRO_AGGR\t%06o\n", PRO_AGGR); + break; + + case 124: + printf("h/catalog.h\tPRO_APP\t\t%06o\n", PRO_APP); + break; + + case 125: + printf("h/catalog.h\tPRO_DEL\t\t%06o\n", PRO_DEL); + break; + + case 126: + printf("h/catalog.h\tPRO_REPL\t%06o\n", PRO_REPL); + break; + + case 127: + printf("h/catalog.h\tPRO_RETR\t%06o\n", PRO_RETR); + break; + + case 128: + printf("h/catalog.h\tPRO_TEST\t%06o\n", PRO_TEST); + break; + + case 129: + printf("h/scanner.h\tPUNCT\t\t%6d\n", PUNCT); + break; + + case 130: + printf("h/pipes.h\tP_END\t\t%6d\n", P_END); + break; + + case 131: + printf("h/pipes.h\tP_EXECID\t%6d\n", P_EXECID); + break; + + case 132: + printf("h/pipes.h\tP_FLUSH\t\t%6d\n", P_FLUSH); + break; + + case 133: + printf("h/pipes.h\tP_FUNCID\t%6d\n", P_FUNCID); + break; + + case 134: + printf("h/pipes.h\tP_INT\t\t%6d\n", P_INT); + break; + + case 135: + printf("h/pipes.h\tP_NORM\t\t%6d\n", P_NORM); + break; + + case 136: + printf("h/pipes.h\tP_PARAM\t\t%6d\n", P_PARAM); + break; + + case 137: + printf("h/pipes.h\tP_PRIME\t\t%6d\n", P_PRIME); + break; + + case 138: + printf("h/pipes.h\tP_SYNC\t\t%6d\n", P_SYNC); + break; + + case 139: + printf("h/pipes.h\tP_WRITE\t\t%6d\n", P_WRITE); + break; + + case 140: + printf("h/catalog.h\tREFOWNER\t%6d\n", REFOWNER); + break; + + case 141: + printf("h/catalog.h\tREFRELID\t%6d\n", REFRELID); + break; + + case 142: + printf("h/catalog.h\tREFTYPE\t\t%6d\n", REFTYPE); + break; + + case 143: + printf("h/ing_db.h\tRELID\t\t%6d\n", RELID); + break; + + case 144: + printf("h/ing_db.h\tRELOWNER\t%6d\n", RELOWNER); + break; + + case 145: + printf("h/version.h\tREL_DATE\t%s\n", REL_DATE); + break; + + case 146: + printf("h/lock.h\tREL_LOCK\t%6ld\n", REL_LOCK); + break; + + case 147: + printf("h/scanner.h\tSBUFOFLO\t%6d\n", SBUFOFLO); + break; + + case 148: + printf("h/scanner.h\tSBUFSIZ\t\t%6d\n", SBUFSIZ); + break; + + case 149: + printf("h/access.h\tSCANTID\t\t%6d\n", SCANTID); + break; + + case 150: + printf("h/catalog.h\tSECBASE\t\t%6d\n", SECBASE); + break; + + case 151: + printf("h/catalog.h\tSECINDEX\t%6d\n", SECINDEX); + break; + + case 152: + printf("h/ing_db.h\tSTACKSIZ\t%6d\n", STACKSIZ); + break; + + case 153: + printf("h/scanner.h\tSTRLONG\t\t%6d\n", STRLONG); + break; + + case 154: + printf("h/scanner.h\tSTRTERM\t\t%6d\n", STRTERM); + break; + + case 155: + printf("h/scanner.h\tSYMERR\t\t%6d\n", SYMERR); + break; + + case 156: + printf("h/pipes.h\tSYNC_STAT\t%6d\n", SYNC_STAT); + break; + + case 157: + printf("h/aux.h\t\tS_BINARY\t%06o\n", S_BINARY); + break; + + case 158: + printf("h/aux.h\t\tS_CATALOG\t%06o\n", S_CATALOG); + break; + + case 159: + printf("h/aux.h\t\tS_CONCUR\t%06o\n", S_CONCUR); + break; + + case 160: + printf("h/aux.h\t\tS_DISCOPY\t%06o\n", S_DISCOPY); + break; + + case 161: + printf("h/aux.h\t\tS_DISCRIT\t%06o\n", S_DISCRIT); + break; + + case 162: + printf("h/aux.h\t\tS_DISTRIBUTED\t%06o\n", S_DISTRIBUTED); + break; + + case 163: + printf("h/aux.h\t\tS_INDEX\t\t%06o\n", S_INDEX); + break; + + case 164: + printf("h/aux.h\t\tS_INTEG\t\t%06o\n", S_INTEG); + break; + + case 165: + printf("h/aux.h\t\tS_NOUPDT\t%06o\n", S_NOUPDT); + break; + + case 166: + printf("h/aux.h\t\tS_PROTALL\t%06o\n", S_PROTALL); + break; + + case 167: + printf("h/aux.h\t\tS_PROTRET\t%06o\n", S_PROTRET); + break; + + case 168: + printf("h/aux.h\t\tS_PROTUPS\t%06o\n", S_PROTUPS); + break; + + case 169: + printf("h/aux.h\t\tS_VBASE\t\t%06o\n", S_VBASE); + break; + + case 170: + printf("h/aux.h\t\tS_VIEW\t\t%06o\n", S_VIEW); + break; + + case 171: + printf("h/catalog.h\tTREEID\t\t%6d\n", TREEID); + break; + + case 172: + printf("h/catalog.h\tTREEOWNER\t%6d\n", TREEOWNER); + break; + + case 173: + printf("h/catalog.h\tTREERELID\t%6d\n", TREERELID); + break; + + case 174: + printf("h/catalog.h\tTREESEQ\t\t%6d\n", TREESEQ); + break; + + case 175: + printf("h/catalog.h\tTREETYPE\t%6d\n", TREETYPE); + break; + + case 176: + printf("h/ing_db.h\tTRUE\t\t%6d\n", TRUE); + break; + + case 177: + printf("h/access.h\tTUP_BUF_SIZ\t%6d\n", TUP_BUF_SIZ); + break; + + case 178: + printf("h/aux.h\t\tUF_DBLIST\t%6d\n", UF_DBLIST); + break; + + case 179: + printf("h/aux.h\t\tUF_FLAGS\t%6d\n", UF_FLAGS); + break; + + case 180: + printf("h/aux.h\t\tUF_GID\t\t%6d\n", UF_GID); + break; + + case 181: + printf("h/aux.h\t\tUF_IFILE\t%6d\n", UF_IFILE); + break; + + case 182: + printf("h/aux.h\t\tUF_NAME\t\t%6d\n", UF_NAME); + break; + + case 183: + printf("h/aux.h\t\tUF_NFIELDS\t%6d\n", UF_NFIELDS); + break; + + case 184: + printf("h/aux.h\t\tUF_PTAB\t\t%6d\n", UF_PTAB); + break; + + case 185: + printf("h/aux.h\t\tUF_STAT\t\t%6d\n", UF_STAT); + break; + + case 186: + printf("h/aux.h\t\tUF_UCODE\t%6d\n", UF_UCODE); + break; + + case 187: + printf("h/aux.h\t\tUF_UID\t\t%6d\n", UF_UID); + break; + + case 188: + printf("h/unix.h\tUSERING_DB\t%s\n", USERING_DB); + break; + + case 189: + printf("h/lock.h\tUSE_LOCK\t%6ld\n", USE_LOCK); + break; + + case 190: + printf("h/aux.h\t\tU_APROCTAB\t%06o\n", U_APROCTAB); + break; + + case 191: + printf("h/aux.h\t\tU_CREATDB\t%06o\n", U_CREATDB); + break; + + case 192: + printf("h/aux.h\t\tU_DRCTUPDT\t%06o\n", U_DRCTUPDT); + break; + + case 193: + printf("h/aux.h\t\tU_EPROCTAB\t%06o\n", U_EPROCTAB); + break; + + case 194: + printf("h/aux.h\t\tU_QRYMODOFF\t%06o\n", U_QRYMODOFF); + break; + + case 195: + printf("h/aux.h\t\tU_SUPER\t\t%06o\n", U_SUPER); + break; + + case 196: + printf("h/aux.h\t\tU_TRACE\t\t%06o\n", U_TRACE); + break; + + case 197: + printf("h/aux.h\t\tU_UPSYSCAT\t%06o\n", U_UPSYSCAT); + break; + + case 198: + printf("h/version.h\tVERSION\t\t%s\n", VERSION); + break; + + case 199: + printf("h/aux.h\t\tWORDSIZE\t%6d\n", WORDSIZE); + break; + + default: + printf("illegal CONST\n"); + } +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/DESC.adb b/WEGA/contrib/ingres/dbs/src/struct/DESC.adb new file mode 100644 index 0000000..da8e581 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/DESC.adb @@ -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 diff --git a/WEGA/contrib/ingres/dbs/src/struct/DESC.c b/WEGA/contrib/ingres/dbs/src/struct/DESC.c new file mode 100644 index 0000000..d6ac6c1 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/DESC.c @@ -0,0 +1,67 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/DESCXX.adb b/WEGA/contrib/ingres/dbs/src/struct/DESCXX.adb new file mode 100644 index 0000000..006a568 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/DESCXX.adb @@ -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 diff --git a/WEGA/contrib/ingres/dbs/src/struct/DESCXX.c b/WEGA/contrib/ingres/dbs/src/struct/DESCXX.c new file mode 100644 index 0000000..faf7e68 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/DESCXX.c @@ -0,0 +1,82 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/DESXX.c b/WEGA/contrib/ingres/dbs/src/struct/DESXX.c new file mode 100644 index 0000000..cae2251 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/DESXX.c @@ -0,0 +1,26 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/INDEX.c b/WEGA/contrib/ingres/dbs/src/struct/INDEX.c new file mode 100644 index 0000000..8096504 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/INDEX.c @@ -0,0 +1,30 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/INTEGRITY.c b/WEGA/contrib/ingres/dbs/src/struct/INTEGRITY.c new file mode 100644 index 0000000..1efafe4 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/INTEGRITY.c @@ -0,0 +1,37 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/LASTOK.c b/WEGA/contrib/ingres/dbs/src/struct/LASTOK.c new file mode 100644 index 0000000..33ce62a --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/LASTOK.c @@ -0,0 +1,28 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/LOCKREQ.c b/WEGA/contrib/ingres/dbs/src/struct/LOCKREQ.c new file mode 100644 index 0000000..75dc7c5 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/LOCKREQ.c @@ -0,0 +1,31 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/OFFEN b/WEGA/contrib/ingres/dbs/src/struct/OFFEN new file mode 100644 index 0000000..7b61001 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/OFFEN @@ -0,0 +1 @@ +../h/access.h struct tup_hdr diff --git a/WEGA/contrib/ingres/dbs/src/struct/OPTAB.c b/WEGA/contrib/ingres/dbs/src/struct/OPTAB.c new file mode 100644 index 0000000..4b3e811 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/OPTAB.c @@ -0,0 +1,28 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/OP_NODE.c b/WEGA/contrib/ingres/dbs/src/struct/OP_NODE.c new file mode 100644 index 0000000..96d6d33 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/OP_NODE.c @@ -0,0 +1,24 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/OUT_ARG.c b/WEGA/contrib/ingres/dbs/src/struct/OUT_ARG.c new file mode 100644 index 0000000..ff9b835 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/OUT_ARG.c @@ -0,0 +1,50 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/PGTUPLE.c b/WEGA/contrib/ingres/dbs/src/struct/PGTUPLE.c new file mode 100644 index 0000000..059279b --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/PGTUPLE.c @@ -0,0 +1,63 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/PIPFRMT.c b/WEGA/contrib/ingres/dbs/src/struct/PIPFRMT.c new file mode 100644 index 0000000..5f9eaed --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/PIPFRMT.c @@ -0,0 +1,35 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/PROTECT.c b/WEGA/contrib/ingres/dbs/src/struct/PROTECT.c new file mode 100644 index 0000000..7077871 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/PROTECT.c @@ -0,0 +1,46 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/QTREE.c b/WEGA/contrib/ingres/dbs/src/struct/QTREE.c new file mode 100644 index 0000000..6b1ce48 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/QTREE.c @@ -0,0 +1,36 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/REFS.c b/WEGA/contrib/ingres/dbs/src/struct/REFS.c new file mode 100644 index 0000000..aa9c0e3 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/REFS.c @@ -0,0 +1,30 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/RELATION.c b/WEGA/contrib/ingres/dbs/src/struct/RELATION.c new file mode 100644 index 0000000..e236e12 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/RELATION.c @@ -0,0 +1,47 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/RES_NODE.c b/WEGA/contrib/ingres/dbs/src/struct/RES_NODE.c new file mode 100644 index 0000000..12bdf94 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/RES_NODE.c @@ -0,0 +1,24 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/RETCODE.c b/WEGA/contrib/ingres/dbs/src/struct/RETCODE.c new file mode 100644 index 0000000..0123e24 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/RETCODE.c @@ -0,0 +1,26 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/ROOT_NODE.c b/WEGA/contrib/ingres/dbs/src/struct/ROOT_NODE.c new file mode 100644 index 0000000..c83daf9 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/ROOT_NODE.c @@ -0,0 +1,32 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/S.c b/WEGA/contrib/ingres/dbs/src/struct/S.c new file mode 100644 index 0000000..24e9f34 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/S.c @@ -0,0 +1,736 @@ +# include +# 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"); + } +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/SI_DOMS.c b/WEGA/contrib/ingres/dbs/src/struct/SI_DOMS.c new file mode 100644 index 0000000..91deb3c --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/SI_DOMS.c @@ -0,0 +1,27 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/SPECIAL.c b/WEGA/contrib/ingres/dbs/src/struct/SPECIAL.c new file mode 100644 index 0000000..ad9b857 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/SPECIAL.c @@ -0,0 +1,40 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/SRCID.c b/WEGA/contrib/ingres/dbs/src/struct/SRCID.c new file mode 100644 index 0000000..8f9494e --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/SRCID.c @@ -0,0 +1,30 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/STRUCTS.VAX b/WEGA/contrib/ingres/dbs/src/struct/STRUCTS.VAX new file mode 100644 index 0000000..d10532e --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/STRUCTS.VAX @@ -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 diff --git a/WEGA/contrib/ingres/dbs/src/struct/SVAR_NODE.c b/WEGA/contrib/ingres/dbs/src/struct/SVAR_NODE.c new file mode 100644 index 0000000..20bdd54 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/SVAR_NODE.c @@ -0,0 +1,30 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/SYMBOL.c b/WEGA/contrib/ingres/dbs/src/struct/SYMBOL.c new file mode 100644 index 0000000..913ac30 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/SYMBOL.c @@ -0,0 +1,30 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/TREE.c b/WEGA/contrib/ingres/dbs/src/struct/TREE.c new file mode 100644 index 0000000..ea7921d --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/TREE.c @@ -0,0 +1,34 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/TUP_HDR.c b/WEGA/contrib/ingres/dbs/src/struct/TUP_HDR.c new file mode 100644 index 0000000..3f2cf45 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/TUP_HDR.c @@ -0,0 +1,32 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/TUP_ID.c b/WEGA/contrib/ingres/dbs/src/struct/TUP_ID.c new file mode 100644 index 0000000..935b361 --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/TUP_ID.c @@ -0,0 +1,61 @@ +# include +# 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); +} diff --git a/WEGA/contrib/ingres/dbs/src/struct/VAR_NODE.c b/WEGA/contrib/ingres/dbs/src/struct/VAR_NODE.c new file mode 100644 index 0000000..22d05bb --- /dev/null +++ b/WEGA/contrib/ingres/dbs/src/struct/VAR_NODE.c @@ -0,0 +1,32 @@ +# include +# 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); +}