/*
** p^n
*/
static int lp_star (lua_State *L) {
int size1;
int n = luaL_checkint(L, 2);
TTree *tree1 = gettree(L, 1, &size1);
if (n >= 0) { /* seq tree1 (seq tree1 ... (seq tree1 (rep tree1))) */
TTree *tree = newtree(L, (n + 1) * (size1 + 1));
if (nullable(tree1))
luaL_error(L, "loop body may accept empty string");
while (n--) /* repeat 'n' times */
tree = seqaux(tree, tree1, size1);
tree->tag = TRep;
memcpy(sib1(tree), tree1, size1 * sizeof(TTree));
}
else { /* choice (seq tree1 ... choice tree1 true ...) true */
TTree *tree;
n = -n;
/* size = (choice + seq + tree1 + true) * n, but the last has no seq */
tree = newtree(L, n * (size1 + 3) - 1);
for (; n > 1; n--) { /* repeat (n - 1) times */
tree->tag = TChoice; tree->u.ps = n * (size1 + 3) - 2;
sib2(tree)->tag = TTrue;
tree = sib1(tree);
tree = seqaux(tree, tree1, size1);
}
tree->tag = TChoice; tree->u.ps = size1 + 1;
sib2(tree)->tag = TTrue;
memcpy(sib1(tree), tree1, size1 * sizeof(TTree));
}
copyktable(L, 1);
return 1;
}
void gettree(node*trev,int x,int y)
{
gotoxy(x,y);
fflush(stdin);
gets(trev->a);
gotoxy(1,25);
printf("want to enter the left node to %6s (y/n) \b",trev->a);
fflush(stdin);
ch=getche();
if(ch=='y'||ch=='Y')
{
gotoxy(x-1,y+1);
printf("/");
gotoxy(x-2,y+2);
printf("/");
node*temp;
temp=(node*)malloc(sizeof(node));
trev->lt=temp;
gettree(temp,x-3,y+3);
}
else
trev->lt=NULL;
gotoxy(1,25);
printf("want to enter the right node to %6s (y/n) \b",trev->a);
fflush(stdin);
ch=getche();
if(ch=='y'||ch=='Y')
{
gotoxy(x+1,y+1);
printf("\\");
gotoxy(x+2,y+2);
printf("\\");
node*temp;
temp=(node*)malloc(sizeof(node));
trev->rt=temp;
gettree(temp,x+3,y+3);
}
else
trev->rt=NULL;
}
static void buildgrammar (lua_State *L, TTree *grammar, int frule, int n) {
int i;
TTree *nd = sib1(grammar); /* auxiliary pointer to traverse the tree */
for (i = 0; i < n; i++) { /* add each rule into new tree */
int ridx = frule + 2*i + 1; /* index of i-th rule */
int rulesize;
TTree *rn = gettree(L, ridx, &rulesize);
nd->tag = TRule;
nd->key = 0;
nd->cap = i; /* rule number */
nd->u.ps = rulesize + 1; /* point to next rule */
memcpy(sib1(nd), rn, rulesize * sizeof(TTree)); /* copy rule */
mergektable(L, ridx, sib1(nd)); /* merge its ktable into new one */
nd = sib2(nd); /* move to next rule */
}
nd->tag = TTrue; /* finish list of rules */
}
/*
** PR_INT -- print an integrity definition given a integrities tuple
**
** Parameters:
** i -- integrity tuple
**
** Returns:
** none
**
** Side Effects:
** prints a query
** reads a tree
*/
void
pr_int(register struct integrity *i, char *relid)
{
register qtree_t *t;
clrrange();
t = gettree(i->intrelid, i->intrelowner, mdINTEG, i->inttree, 0);
printf("Integrity constraint %d -\n\n", i->inttree);
pr_range();
printf("define integrity on ");
pr_rv(Qt.qt_resvar = i->intresvar);
printf(" is ");
pr_qual(t->right);
printf("\n\n\n");
}
/*
** Convert value at index 'idx' to a pattern
*/
static TTree *getpatt (lua_State *L, int idx, int *len) {
TTree *tree;
switch (lua_type(L, idx)) {
case LUA_TSTRING: {
size_t slen;
const char *s = lua_tolstring(L, idx, &slen); /* get string */
if (slen == 0) /* empty? */
tree = newleaf(L, TTrue); /* always match */
else {
tree = newtree(L, 2 * (slen - 1) + 1);
fillseq(tree, TChar, slen, s); /* sequence of 'slen' chars */
}
break;
}
case LUA_TNUMBER: {
int n = lua_tointeger(L, idx);
tree = numtree(L, n);
break;
}
case LUA_TBOOLEAN: {
tree = (lua_toboolean(L, idx) ? newleaf(L, TTrue) : newleaf(L, TFalse));
break;
}
case LUA_TTABLE: {
tree = newgrammar(L, idx);
break;
}
case LUA_TFUNCTION: {
tree = newtree(L, 2);
tree->tag = TRunTime;
tree->key = addtonewktable(L, 0, idx);
sib1(tree)->tag = TTrue;
break;
}
default: {
return gettree(L, idx, len);
}
}
lua_replace(L, idx); /* put new tree into 'idx' slot */
if (len)
*len = getsize(L, idx);
return tree;
}
/*
** PR_DEF -- Print "define view" query of a view
**
** Parameters:
** relation -- relation in question
** owner -- relowner
**
** Returns:
** none
**
** Side Effects:
** reads a tree, clears range table
**
** Trace Flags:
** 33, 9
*/
void
pr_def(char *relation, char *owner)
{
register qtree_t *t;
#ifdef xZTR1
if (tTf(50, 9))
printf("pr_def(relation=\"%s\", owner=%s)\n", relation, owner);
#endif
printf("View %s defined:\n\n", relation);
clrrange();
/* Treeid == 0 because views have only one definition */
t = gettree(relation, owner, mdVIEW, 0,FALSE);
pr_range();
printf("define view ");
pr_tree(t);
}
void main()
{
node*root,*root1;
clrscr();
gotoxy(1,25);
cout<<"enter the tree";
root=new node;
gettree(root,40,1);
cout<<"the tree loaded";
sound(200);
delay(1000);
nosound();
getch();
getch();
clrscr();
showtree(root,40,10);
getch();
root1=new node;
createig(root,root1);
clrscr();
showtree(root1,40,10);
getch();
}
static OCTREE
gettree() /* get a pre-ordered octree */
{
register OCTREE ot;
register int i;
switch (getc(infp)) {
case OT_EMPTY:
return(EMPTY);
case OT_FULL:
return(getfullnode());
case OT_TREE:
if ((ot = octalloc()) == EMPTY)
octerror(SYSTEM, "out of tree space in gettree");
for (i = 0; i < 8; i++)
octkid(ot, i) = gettree();
return(ot);
case EOF:
octerror(USER, "truncated octree");
default:
octerror(USER, "damaged octree");
}
return EMPTY; /* pro forma return */
}
int
readoct( /* read in octree file or stream */
char *inpspec,
int load,
CUBE *scene,
char *ofn[]
)
{
char sbuf[512];
int nf;
int i;
long m;
if (inpspec == NULL) {
infn = "standard input";
infp = stdin;
} else if (inpspec[0] == '!') {
infn = inpspec;
if ((infp = popen(inpspec+1, "r")) == NULL) {
sprintf(errmsg, "cannot execute \"%s\"", inpspec);
error(SYSTEM, errmsg);
}
} else {
infn = inpspec;
if ((infp = fopen(inpspec, "r")) == NULL) {
sprintf(errmsg, "cannot open octree file \"%s\"",
inpspec);
error(SYSTEM, errmsg);
}
}
SET_FILE_BINARY(infp);
/* get header */
if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)NULL) < 0)
octerror(USER, "not an octree");
/* check format */
if ((objsize = ogetint(2)-OCTMAGIC) <= 0 ||
objsize > MAXOBJSIZ || objsize > sizeof(long))
octerror(USER, "incompatible octree format");
/* get boundaries */
if (load & IO_BOUNDS) {
for (i = 0; i < 3; i++)
scene->cuorg[i] = atof(ogetstr(sbuf));
scene->cusize = atof(ogetstr(sbuf));
} else {
for (i = 0; i < 4; i++)
ogetstr(sbuf);
}
objorig = nobjects; /* set object offset */
nf = 0; /* get object files */
while (*ogetstr(sbuf)) {
if (load & IO_SCENE)
readobj(sbuf);
if (load & IO_FILES)
ofn[nf] = savqstr(sbuf);
nf++;
}
if (load & IO_FILES)
ofn[nf] = NULL;
/* get number of objects */
fnobjects = m = ogetint(objsize);
if (fnobjects != m)
octerror(USER, "too many objects");
if (load & IO_TREE) /* get the octree */
scene->cutree = gettree();
else if (load & IO_SCENE && nf == 0)
skiptree();
if (load & IO_SCENE) { /* get the scene */
if (nf == 0) {
/* load binary scene data */
readscene(infp, objsize);
} else { /* consistency checks */
/* check object count */
if (nobjects != objorig+fnobjects)
octerror(USER, "bad object count; octree stale?");
/* check for non-surfaces */
if (nonsurfintree(scene->cutree))
octerror(USER, "modifier in tree; octree stale?");
}
}
/* close the input */
if (infn[0] == '!')
pclose(infp);
else
fclose(infp);
return(nf);
}
