ING_DB
This commit is contained in:
Oliver Lehmann
parent
eefa54f77f
commit
541d815424
|
|
@ -0,0 +1,306 @@
|
||||||
|
# include <stdio.h>
|
||||||
|
# include "gen.h"
|
||||||
|
# include "../h/bs.h"
|
||||||
|
# include "constants.h"
|
||||||
|
# include "globals.h"
|
||||||
|
|
||||||
|
static struct display Symsp; /* storage for symbols read by */
|
||||||
|
/* yylex() */
|
||||||
|
static struct display Displays[1]; /* Cv_display is set to point at */
|
||||||
|
/* this, so that Cv_display may be */
|
||||||
|
/* passed a parameter instead of */
|
||||||
|
/* &Cv_display */
|
||||||
|
struct display *Cv_display = &Displays[0];
|
||||||
|
|
||||||
|
/*
|
||||||
|
** DISPLAY.C -- display manipulation routines
|
||||||
|
**
|
||||||
|
** a display is a list of strings, the symbol
|
||||||
|
** space Symsp is impemented by means of displays.
|
||||||
|
**
|
||||||
|
** Defines:
|
||||||
|
** enter_display()
|
||||||
|
** addsym()
|
||||||
|
** free_display()
|
||||||
|
** symspfree()
|
||||||
|
** w_display()
|
||||||
|
** eat_display()
|
||||||
|
**
|
||||||
|
**
|
||||||
|
**
|
||||||
|
** this avoids having to specify &Cv_display in the semantic
|
||||||
|
** routines, by making Cv_display a pointer to the pertinent
|
||||||
|
** display structure.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
** ENTER_DISPLAY -- enter a new string into a display
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** disp -- display to be added to
|
||||||
|
** string -- string to add
|
||||||
|
**
|
||||||
|
** Returns:
|
||||||
|
** pointer to new disp_node structure.
|
||||||
|
**
|
||||||
|
** Side Effects:
|
||||||
|
** allocates a new disp_node structure.
|
||||||
|
** Expects a dynamic "string", i.e. one that it can
|
||||||
|
** dispose of as it wishes, so it is the users responsability
|
||||||
|
** to allocate space for this string.
|
||||||
|
** If the string passed is 0, the string
|
||||||
|
** "ERROR_TOKEN" is substituted, and a message is printed,
|
||||||
|
** so a caller may call enter_display with the return of an
|
||||||
|
** salloc() directly.
|
||||||
|
** If no space is available for the allocation of the
|
||||||
|
** new node, an error message is given, and a longjump(3)
|
||||||
|
** is performed (this should goto eql()[main.c])
|
||||||
|
*/
|
||||||
|
struct disp_node *enter_display(disp, string)
|
||||||
|
register struct display *disp;
|
||||||
|
register char *string;
|
||||||
|
{
|
||||||
|
register struct disp_node *node;
|
||||||
|
extern char *nalloc();
|
||||||
|
|
||||||
|
node = (struct disp_node *) nalloc(sizeof *node);
|
||||||
|
if (!node)
|
||||||
|
{
|
||||||
|
yysemerr("symbol space overflow", string);
|
||||||
|
reset();
|
||||||
|
}
|
||||||
|
if (!disp->disp_first)
|
||||||
|
disp->disp_first = disp->disp_last = node;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
disp->disp_last->d_next = node;
|
||||||
|
disp->disp_last = node;
|
||||||
|
}
|
||||||
|
node->d_next = 0;
|
||||||
|
if (!(node->d_elm = string))
|
||||||
|
{
|
||||||
|
printf("alloc error in display\n");
|
||||||
|
node->d_elm = "ERROR_TOKEN";
|
||||||
|
}
|
||||||
|
return (node);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** ADDSYM -- add a token to the symbol space
|
||||||
|
**
|
||||||
|
** The node's .d_line field is set to the value of yyline,
|
||||||
|
** which, if this routine is called from a lexical routine
|
||||||
|
** taking lexemes that can't include newlines (and back them up),
|
||||||
|
** is the line the lexeme was read from. This fact is used
|
||||||
|
** be yyserror()[yyerror.c] to report accurate line numbers
|
||||||
|
** for errors.
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** s -- string to add
|
||||||
|
**
|
||||||
|
** Returns:
|
||||||
|
** pointer to node added
|
||||||
|
*/
|
||||||
|
struct disp_node *addsym(s)
|
||||||
|
register char *s;
|
||||||
|
{
|
||||||
|
register struct disp_node *d;
|
||||||
|
|
||||||
|
d = enter_display(&Symsp, s);
|
||||||
|
d->d_line = yyline;
|
||||||
|
return (d);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** FREE_DISPLAY -- frees all elements of a display
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** disp -- the display to free
|
||||||
|
*/
|
||||||
|
free_display(disp)
|
||||||
|
register struct display *disp;
|
||||||
|
{
|
||||||
|
register struct disp_node *f;
|
||||||
|
register struct disp_node *n;
|
||||||
|
|
||||||
|
for (f = disp->disp_first; f; f = n)
|
||||||
|
{
|
||||||
|
n = f->d_next;
|
||||||
|
xfree(f->d_elm);
|
||||||
|
xfree(f);
|
||||||
|
}
|
||||||
|
disp->disp_first = disp->disp_last = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** SYSMSPFREE -- Frees symbol space
|
||||||
|
** Symspfree frees all the symbol table, EXCEPT
|
||||||
|
** for the last element in it, as this is the lookahead
|
||||||
|
** element. That is to say, the element which forced reduction
|
||||||
|
** to the non-terminal program, which called on symspfree()
|
||||||
|
*/
|
||||||
|
symspfree()
|
||||||
|
{
|
||||||
|
register struct display *d;
|
||||||
|
register struct disp_node *f;
|
||||||
|
register struct disp_node *n;
|
||||||
|
|
||||||
|
d = &Symsp;
|
||||||
|
for (f = d->disp_first; f && f->d_next; f = n)
|
||||||
|
{
|
||||||
|
n = f->d_next;
|
||||||
|
xfree(f->d_elm);
|
||||||
|
xfree(f);
|
||||||
|
}
|
||||||
|
d->disp_first = d->disp_last;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** W_DISPLAY -- write out the contents of a display
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** disp -- display to take write out
|
||||||
|
**
|
||||||
|
** Side Effects:
|
||||||
|
** Writes onto Out_file
|
||||||
|
** the contents of the display,
|
||||||
|
** each string is comsidered a separate
|
||||||
|
** word to be written out(so w_raw may
|
||||||
|
** break a line between words).
|
||||||
|
** Calls are made to w_raw() and w_key() so as
|
||||||
|
** to have the minimum number of spaces in the text.
|
||||||
|
*/
|
||||||
|
w_display(disp)
|
||||||
|
register struct display *disp;
|
||||||
|
{
|
||||||
|
register struct disp_node *n;
|
||||||
|
register int i;
|
||||||
|
|
||||||
|
for (n = disp->disp_first; n; n = n->d_next)
|
||||||
|
{
|
||||||
|
i = AAlength(n->d_elm);
|
||||||
|
i = n->d_elm[i - 1];
|
||||||
|
switch (CMAP(i))
|
||||||
|
{
|
||||||
|
case OPATR :
|
||||||
|
case PUNCT :
|
||||||
|
w_raw(n->d_elm);
|
||||||
|
break;
|
||||||
|
|
||||||
|
default :
|
||||||
|
w_key(n->d_elm);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** EAT_DISPLAY -- enter text from In_file into a display
|
||||||
|
** Enters all text gotten through getch()[getch.c]
|
||||||
|
** lying between one character delimiters, which may
|
||||||
|
** be nested, into a display or w_raw()'s it.
|
||||||
|
** eat_display() assumes that when it is called a
|
||||||
|
** "left_ch" has just been seen. It will "eat" up to
|
||||||
|
** MAXSTRING characters.
|
||||||
|
** Newline is played with because :
|
||||||
|
** a) a newline may have been read by eat_display
|
||||||
|
** instead of yylex(), therefore if eat_display
|
||||||
|
** stops there, yylex() must know that a newline
|
||||||
|
** has just been seen and it must test for C_CODE.
|
||||||
|
** b) Newline may have to be set to 0 if an include()
|
||||||
|
** was done which sets it to 1, and no yylex() was
|
||||||
|
** done afterwards to reset it.
|
||||||
|
**
|
||||||
|
** NOTE : This playing with Newline is needed because
|
||||||
|
** yylex() and not getch() maintains Newline. If getch()
|
||||||
|
** maintained Newline then it would be automatically right.
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** disp -- display to add elements to if != 0 else
|
||||||
|
** characters are written out.
|
||||||
|
** left_ch -- left delimiter character
|
||||||
|
** right_ch -- right delimiter character
|
||||||
|
**
|
||||||
|
** Side Effects:
|
||||||
|
** advances input to after the close of the
|
||||||
|
** left_ch, right_ch pair.
|
||||||
|
** may back up 2 characters.
|
||||||
|
**
|
||||||
|
** Bugs:
|
||||||
|
** #include's encountered, are treated wrongly
|
||||||
|
** because the "#include ...c.h" is put out immediately,
|
||||||
|
** while the display is put out only later.
|
||||||
|
*/
|
||||||
|
eat_display(disp, left_ch, right_ch)
|
||||||
|
struct display *disp;
|
||||||
|
char left_ch;
|
||||||
|
char right_ch;
|
||||||
|
{
|
||||||
|
register char *cp;
|
||||||
|
register int level;
|
||||||
|
register int i;
|
||||||
|
register int pk;
|
||||||
|
char r_c[2];
|
||||||
|
char buf[MAXSTRING + 1];
|
||||||
|
extern char *salloc();
|
||||||
|
|
||||||
|
cp = buf;
|
||||||
|
level = i = 1;
|
||||||
|
*cp = left_ch;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
i++;
|
||||||
|
if (i >= sizeof buf)
|
||||||
|
{
|
||||||
|
yysemerr("display too long", (char *) 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if ((*++cp = getch()) == left_ch)
|
||||||
|
level++;
|
||||||
|
else if (*cp == right_ch)
|
||||||
|
level -= 1;
|
||||||
|
else if (*cp == EOF_TOK)
|
||||||
|
{
|
||||||
|
backup(*cp);
|
||||||
|
missing :
|
||||||
|
r_c[1] = '\0';
|
||||||
|
r_c[0] = right_ch;
|
||||||
|
yysemerr("missing closing character", r_c);
|
||||||
|
*cp = right_ch;
|
||||||
|
/* make next line be read as possible
|
||||||
|
* C_CODE by yylex()[yylex.c]
|
||||||
|
*/
|
||||||
|
Newline = 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else if (*cp == '\n')
|
||||||
|
{
|
||||||
|
/* test that next line is valid EQL line,
|
||||||
|
* and strip "##"
|
||||||
|
*/
|
||||||
|
if ((pk = getch()) != '#')
|
||||||
|
{
|
||||||
|
backup(pk);
|
||||||
|
goto missing;
|
||||||
|
}
|
||||||
|
if ((pk = getch()) != '#')
|
||||||
|
{
|
||||||
|
backup(pk);
|
||||||
|
backup('#');
|
||||||
|
goto missing;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} while (*cp != right_ch || level > 0);
|
||||||
|
if (!level)
|
||||||
|
Newline = 0;
|
||||||
|
*++cp = '\0';
|
||||||
|
if (disp)
|
||||||
|
enter_display(disp, salloc(buf));
|
||||||
|
else
|
||||||
|
w_raw(buf);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,252 @@
|
||||||
|
# include <stdio.h>
|
||||||
|
# include "gen.h"
|
||||||
|
# include "constants.h"
|
||||||
|
# include "globals.h"
|
||||||
|
|
||||||
|
struct inc_file *Inc_file; /* file stack pushed by #includes */
|
||||||
|
|
||||||
|
/*
|
||||||
|
** INLUDE.C -- Routine to process "#include" lines
|
||||||
|
**
|
||||||
|
** Defines:
|
||||||
|
** tst_include()
|
||||||
|
** include()
|
||||||
|
** restoref()
|
||||||
|
**
|
||||||
|
**
|
||||||
|
**
|
||||||
|
** TST_INCLUDE -- Test and process a "#include" line
|
||||||
|
**
|
||||||
|
** Checks that a line is of the form '# include "<filename.q.h>"',
|
||||||
|
** and calls include to change i/o files if so.
|
||||||
|
**
|
||||||
|
** Returns:
|
||||||
|
** 1 -- if change of file was done
|
||||||
|
** 0 -- otherwise
|
||||||
|
*/
|
||||||
|
tst_include()
|
||||||
|
{
|
||||||
|
register char *lp;
|
||||||
|
register char *tp;
|
||||||
|
register char *chp;
|
||||||
|
char temp[MAXSTRING + 1];
|
||||||
|
|
||||||
|
/* copy line read into temp ( because temp is same
|
||||||
|
* size as Linebuf, no overflow check is needed
|
||||||
|
*/
|
||||||
|
for (tp = temp, lp = Line_buf; (*tp++ = *lp++) != '\n'; )
|
||||||
|
continue;
|
||||||
|
/* skip white space between "#" and "include" */
|
||||||
|
for (tp = &temp[1]; *tp == ' ' || *tp == '\t'; tp++)
|
||||||
|
continue;
|
||||||
|
if (AAscompare("include", 7, tp, 7))
|
||||||
|
return (0);
|
||||||
|
/* skip "include", the white space till '"' */
|
||||||
|
for (tp = &tp[7]; *tp == ' ' || *tp == '\t'; tp++)
|
||||||
|
continue;
|
||||||
|
if (*tp++ != '"')
|
||||||
|
return (0);
|
||||||
|
|
||||||
|
/* {tp points to X in a line "#<white>include<white>"X..." }
|
||||||
|
* make "lp" point at right end '"' (filename must not have
|
||||||
|
* escaped '"' in it
|
||||||
|
*/
|
||||||
|
for (lp = tp; *lp != '"' && *lp != '\n'; lp++)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (*lp != '"')
|
||||||
|
return (0);
|
||||||
|
/* make sure filename is long enough to have the EQL "include"
|
||||||
|
* suffix ".q.h"
|
||||||
|
*/
|
||||||
|
if (lp - tp < 4)
|
||||||
|
return (0);
|
||||||
|
if (AAscompare(".q.h", 4, &lp[-4], 4))
|
||||||
|
return (0); /* other include (non-EQL) */
|
||||||
|
|
||||||
|
/* "chp" points at 'q' in '.q.h' which will be changed to 'c' */
|
||||||
|
chp = &lp[-3];
|
||||||
|
|
||||||
|
/* check that rest of the line is white space */
|
||||||
|
for (lp++; *lp == ' ' || *lp == '\t'; lp++)
|
||||||
|
continue;
|
||||||
|
if (*lp != '\n')
|
||||||
|
{
|
||||||
|
*lp = '\0';
|
||||||
|
yysemerr("garbage after valid \"#include\"", temp);
|
||||||
|
return (0);
|
||||||
|
}
|
||||||
|
*++lp = '\0';
|
||||||
|
return (include(temp, tp, chp, &chp[3]));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
** INCLUDE -- Change i/o files for a file inclusion
|
||||||
|
** Saves status of current i/o files, puts out
|
||||||
|
** '#include"___.c.h"', and opens appropriate files.
|
||||||
|
** Makes both files legal C files, closing quotes,
|
||||||
|
** and reopeneing them in the new file, if necessary.
|
||||||
|
** Reuses Out_buf.
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** buf -- "#include..." line
|
||||||
|
** start -- start of filename
|
||||||
|
** chp -- *chp is 'q' in ".q.h" of filename
|
||||||
|
** end -- ptr to last '"' after filename
|
||||||
|
**
|
||||||
|
** Returns:
|
||||||
|
** 1 -- if i/o files changed
|
||||||
|
** 0 -- otherwise
|
||||||
|
*/
|
||||||
|
include(buf, start, chp, end)
|
||||||
|
char *buf;
|
||||||
|
char *start;
|
||||||
|
char *chp;
|
||||||
|
char *end;
|
||||||
|
{
|
||||||
|
register struct inc_file *i_f;
|
||||||
|
register int in_q_flag;
|
||||||
|
# ifdef SETBUF
|
||||||
|
register char *ibuf;
|
||||||
|
# endif
|
||||||
|
extern char *nalloc();
|
||||||
|
extern char *salloc();
|
||||||
|
|
||||||
|
in_q_flag = In_quote;
|
||||||
|
if (in_q_flag)
|
||||||
|
{
|
||||||
|
end_quote();
|
||||||
|
equate_lines();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(i_f = (struct inc_file *) nalloc(sizeof *i_f)))
|
||||||
|
{
|
||||||
|
err1 :
|
||||||
|
*++end = '\0'; /* overwrite before new-line at end */
|
||||||
|
yysemerr("alloc error in #include processing", buf);
|
||||||
|
if (in_q_flag)
|
||||||
|
begin_quote();
|
||||||
|
*end = '\n';
|
||||||
|
return (0);
|
||||||
|
}
|
||||||
|
# ifdef SETBUF
|
||||||
|
if (!(ibuf = nalloc(BUFSIZ)))
|
||||||
|
goto err2;
|
||||||
|
# endif
|
||||||
|
i_f->inc_yyline = yyline + 1; /* next line that will be read is
|
||||||
|
* yyline + 1 because getch does not
|
||||||
|
* see the '\n' at the end of the
|
||||||
|
* "#include" line
|
||||||
|
*/
|
||||||
|
i_f->inc_lineout = Lineout + 1; /* because the write of the "#include
|
||||||
|
* "... .c.h" file is done after the
|
||||||
|
* fixation of the value of Lineout.
|
||||||
|
*/
|
||||||
|
i_f->inc_fid = Input_file_name;
|
||||||
|
i_f->inc_outfile = Out_file;
|
||||||
|
i_f->inc_infile = In_file;
|
||||||
|
# ifdef SETBUF
|
||||||
|
i_f->inc_ibuf = Ibuf;
|
||||||
|
# endif
|
||||||
|
i_f->inc_next = 0;
|
||||||
|
|
||||||
|
*end = '\0';
|
||||||
|
if (!(Input_file_name = salloc(start)))
|
||||||
|
{
|
||||||
|
# ifdef SETBUF
|
||||||
|
xfree(ibuf);
|
||||||
|
# endif
|
||||||
|
err2 :
|
||||||
|
xfree(i_f);
|
||||||
|
goto err1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(In_file = fopen(Input_file_name, "r")))
|
||||||
|
{
|
||||||
|
printf("can't read included file \"%s\"\n", Input_file_name);
|
||||||
|
err3 :
|
||||||
|
xfree(Input_file_name);
|
||||||
|
Input_file_name = i_f->inc_fid;
|
||||||
|
In_file = i_f->inc_infile;
|
||||||
|
# ifdef SETBUF
|
||||||
|
xfree(ibuf);
|
||||||
|
# endif
|
||||||
|
xfree(i_f);
|
||||||
|
return (0);
|
||||||
|
}
|
||||||
|
# ifdef SETBUF
|
||||||
|
setbuf(In_file, ibuf);
|
||||||
|
# endif
|
||||||
|
*end = '"';
|
||||||
|
*chp = 'c';
|
||||||
|
|
||||||
|
/* write out "#include..c.h" line (make sure it's at beginning
|
||||||
|
* of line.
|
||||||
|
*/
|
||||||
|
equate_lines();
|
||||||
|
if (Charcnt)
|
||||||
|
w_raw("\n");
|
||||||
|
w_raw(buf);
|
||||||
|
fflush(Out_file);
|
||||||
|
*end = '\0';
|
||||||
|
if (!(Out_file = fopen(start, "w")))
|
||||||
|
{
|
||||||
|
printf("can't write file \"%s\"\n", start);
|
||||||
|
fclose(In_file);
|
||||||
|
Out_file = i_f->inc_outfile;
|
||||||
|
goto err3;
|
||||||
|
}
|
||||||
|
# ifdef SETBUF
|
||||||
|
setbuf(Out_file, Out_buf);
|
||||||
|
Ibuf = ibuf;
|
||||||
|
# endif
|
||||||
|
/* go to it !!! */
|
||||||
|
Lineout = yyline = Newline = 1;
|
||||||
|
Pre_proc_flag = 0;
|
||||||
|
Line_pos = (char *) 0;
|
||||||
|
if (in_q_flag)
|
||||||
|
begin_quote();
|
||||||
|
Inc_file = i_f;
|
||||||
|
return (1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** RESTOREF -- Restore previous file environment
|
||||||
|
** Closes current files, and restores global variable
|
||||||
|
** values for old files.
|
||||||
|
**
|
||||||
|
** Returns:
|
||||||
|
** 0 -- if no old files (top level, no "#include"s)
|
||||||
|
** 1 -- otherwise
|
||||||
|
*/
|
||||||
|
restoref()
|
||||||
|
{
|
||||||
|
register struct inc_file *i_f;
|
||||||
|
|
||||||
|
if (Inc_file)
|
||||||
|
{
|
||||||
|
fclose(Out_file);
|
||||||
|
fclose(In_file);
|
||||||
|
# ifdef SETBUF
|
||||||
|
xfree(Ibuf);
|
||||||
|
# endif
|
||||||
|
xfree(Input_file_name);
|
||||||
|
|
||||||
|
/* restore previous environment */
|
||||||
|
i_f = Inc_file;
|
||||||
|
yyline = i_f->inc_yyline;
|
||||||
|
Lineout = i_f->inc_lineout;
|
||||||
|
# ifdef SETBUF
|
||||||
|
Ibuf = i_f->inc_ibuf;
|
||||||
|
# endif
|
||||||
|
Input_file_name = i_f->inc_fid;
|
||||||
|
Out_file = i_f->inc_outfile;
|
||||||
|
In_file = i_f->inc_infile;
|
||||||
|
Line_pos = (char *) 0;
|
||||||
|
Inc_file = i_f->inc_next;
|
||||||
|
xfree(i_f);
|
||||||
|
return (1);
|
||||||
|
}
|
||||||
|
return (0);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,151 @@
|
||||||
|
# include <stdio.h>
|
||||||
|
# include "gen.h"
|
||||||
|
# include "constants.h"
|
||||||
|
# include "globals.h"
|
||||||
|
|
||||||
|
static struct ret_list Ret_list; /* list of variables in a "ctlelm" */
|
||||||
|
|
||||||
|
/*
|
||||||
|
** RETRIEVE.C -- ret_list struct handlers
|
||||||
|
**
|
||||||
|
** The Ret_list is a structure where references to C variables,
|
||||||
|
** and their types, used in a target list of a "tupret" are kept
|
||||||
|
** for outputting in the while loop generated.
|
||||||
|
**
|
||||||
|
** Defines:
|
||||||
|
** enter_ret()
|
||||||
|
** add_ret()
|
||||||
|
** w_ret()
|
||||||
|
** free_ret()
|
||||||
|
**
|
||||||
|
**
|
||||||
|
**
|
||||||
|
** ENTER_RET -- enter a variable in a ret_list
|
||||||
|
** Concatenatest the strings in disp the calls add_ret
|
||||||
|
** to add the new string to Ret_list.
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** disp -- display containing the reference to the variable
|
||||||
|
** type -- type of the variable
|
||||||
|
*/
|
||||||
|
enter_ret(disp, type)
|
||||||
|
struct display *disp;
|
||||||
|
int type;
|
||||||
|
{
|
||||||
|
register char *srce;
|
||||||
|
register char *dest;
|
||||||
|
register struct disp_node *d;
|
||||||
|
register int i;
|
||||||
|
char buf[MAXSTRING + 2];
|
||||||
|
extern char *salloc();
|
||||||
|
|
||||||
|
i = 0;
|
||||||
|
dest = buf;
|
||||||
|
for (d = disp->disp_first; d; d = d->d_next)
|
||||||
|
{
|
||||||
|
for (srce = d->d_elm; *srce; )
|
||||||
|
{
|
||||||
|
if (i < MAXSTRING)
|
||||||
|
{
|
||||||
|
i += 1;
|
||||||
|
*++dest = *srce++;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (i >= MAXSTRING)
|
||||||
|
{
|
||||||
|
yysemerr("reference to a variable too long, ']' probably missing from array subscription", (char *) 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
*++dest = '\0';
|
||||||
|
add_ret(salloc(&buf[1]), type);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** ADD_RET -- add a string (reference to a variable) to the Ret_list
|
||||||
|
**
|
||||||
|
** Parameters:
|
||||||
|
** s -- string to add
|
||||||
|
** type -- type of variable being added
|
||||||
|
*/
|
||||||
|
add_ret(s, type)
|
||||||
|
char *s;
|
||||||
|
int type;
|
||||||
|
{
|
||||||
|
register struct ret_list *list;
|
||||||
|
register struct ret_var *node;
|
||||||
|
extern char *nalloc();
|
||||||
|
|
||||||
|
if (!s)
|
||||||
|
{
|
||||||
|
s = "ERROR_TOKEN";
|
||||||
|
yysemerr("alloc error", s);
|
||||||
|
}
|
||||||
|
list = &Ret_list;
|
||||||
|
node = (struct ret_var *) nalloc(sizeof *node);
|
||||||
|
if (!node)
|
||||||
|
{
|
||||||
|
yysemerr("alloc error", s);
|
||||||
|
xfree(s);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
node->r_elm = s;
|
||||||
|
node->r_next = 0;
|
||||||
|
node->r_type = type;
|
||||||
|
if (!list->ret_first)
|
||||||
|
list->ret_first = list->ret_last = node;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
list->ret_last->r_next = node;
|
||||||
|
list->ret_last = node;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** W_RET -- Generates the IIn_get() calls for the Ret_list
|
||||||
|
**
|
||||||
|
** Any variable whose type is not string gets an '&'
|
||||||
|
** (adress of) operand prepended.
|
||||||
|
*/
|
||||||
|
w_ret()
|
||||||
|
{
|
||||||
|
register struct ret_var *node;
|
||||||
|
char type[3];
|
||||||
|
|
||||||
|
for (node = Ret_list.ret_first; node; node = node->r_next)
|
||||||
|
{
|
||||||
|
w_raw("IIn_ret(");
|
||||||
|
if (node->r_type != opSTRING)
|
||||||
|
w_raw("&");
|
||||||
|
w_raw(node->r_elm);
|
||||||
|
w_raw(", ");
|
||||||
|
AA_itoa(node->r_type, type);
|
||||||
|
w_raw(type);
|
||||||
|
w_raw(");");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
** FRE_RET -- Free up the storage used by the Ret_list
|
||||||
|
*/
|
||||||
|
free_ret()
|
||||||
|
{
|
||||||
|
register struct ret_list *list;
|
||||||
|
register struct ret_var *n;
|
||||||
|
register struct ret_var *f;
|
||||||
|
|
||||||
|
list = &Ret_list;
|
||||||
|
for (f = list->ret_first; f; f = n)
|
||||||
|
{
|
||||||
|
n = f->r_next;
|
||||||
|
xfree(f->r_elm);
|
||||||
|
xfree(f);
|
||||||
|
}
|
||||||
|
list->ret_first = list->ret_last = 0;
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue