Bscript::BStruct* UMulti::footprint() const
{
const MultiDef& md = multidef();
std::unique_ptr<Bscript::BStruct> ret( new Bscript::BStruct );
ret->addMember( "xmin", new Bscript::BLong( x + md.minrx ) );
ret->addMember( "xmax", new Bscript::BLong( x + md.maxrx ) );
ret->addMember( "ymin", new Bscript::BLong( y + md.minry ) );
ret->addMember( "ymax", new Bscript::BLong( y + md.maxry ) );
return ret.release();
}
TAG_SYMBOL *
defstruct (char *sname, int storage, int is_struct)
{
int itag ; /* index of tag in tag symbol table */
char nam[20]; /* Dummy name */
TAG_SYMBOL *tag = NULL;
if ( tagptr >= ENDTAG ) {
error(E_STROV) ;
}
if ( sname && sname[0] == 0 )
sname = NULL;
if ( sname && (tag = findtag(sname) ) ) {
if ( tag->weak == 0 ) {
if ( rcmatch('{') )
multidef();
else
return tag;
}
itag = tag - tagtab;
}
/* No tag defined for this, so leave it alone */
if ( tag == NULL ) {
tag = tagptr++;
itag = tag - tagtab ;
sprintf(nam,"0st%d",itag);
if ( sname == NULL )
sname = nam;
strcpy(tag->name,sname);
tag->size = 0;
tag->ptr = tag->end = membptr ; /* Set so no member searches done.. */
dummy_sym[NTYPE+1+itag] = addglb(nam,POINTER,STRUCT,0,STATIK,0,itag) ;
tag->weak = 1;
}
if ( rcmatch('{' ) ) {
/* increment tagptr to add tag to table */
tag->ptr = membptr;
tag->weak = 0;
needchar('{') ;
while ( dodeclare(storage, tag, is_struct) )
;
needchar('}') ;
tag->end = membptr ;
}
return tag ;
}
void doLocalAnsiArgument(int type) {
char symbol_name[NAMESIZE];
int identity, address, argptr, ptr;
if (match("*")) {
identity = POINTER;
} else {
if (type == STRUCT) {
error("cannot pass struct");
return;
}
identity = VARIABLE;
if (type == VOID)
return;
}
if (symname(symbol_name)) {
if (find_locale(symbol_name) > -1) {
multidef(symbol_name);
} else {
argptr = add_local (symbol_name, identity, type, 0, AUTO);
argstk = argstk + INTSIZE;
ptr = local_table_index;
while (ptr != NUMBER_OF_GLOBALS) { // modify stack offset as we push more params
ptr = ptr - 1;
address = symbol_table[ptr].offset;
symbol_table[ptr].offset = address + INTSIZE;
/* Struct etc FIXME */
}
}
} else {
error("illegal argument name");
junk();
}
if (match("[")) {
while (inbyte() != ']') {
if (endst()) {
break;
}
}
identity = POINTER;
symbol_table[argptr].identity = identity;
}
}
void newfunc_typed(int storage, char *n, int type)
{
int idx;
SYMBOL *symbol;
char an[NAMESIZE];
fexitlab = getlabel();
if ((idx = find_global(n)) > -1) {
symbol = &symbol_table[idx];
if (symbol->identity != FUNCTION)
multidef(n);
} else {
/* extern implies global scope */
idx = add_global(n, FUNCTION, CINT, 0, storage == EXTERN ? PUBLIC : storage);
symbol = &symbol_table[idx];
}
local_table_index = NUMBER_OF_GLOBALS; //locptr = STARTLOC;
argstk = 0;
// ANSI style argument declaration
if (doAnsiArguments()) {
if (storage == EXTERN) {
need_semicolon();
return;
}
/* No body .. just a definition */
if (match(";"))
return;
} else {
// K&R style argument declaration
while (!match(")")) {
if (symname(an)) {
if (find_locale(an) > -1)
multidef(an);
else {
/* FIXME: struct */
add_local(an, 0, 0, argstk, AUTO);
argstk = argstk + INTSIZE;
}
} else {
error("illegal argument name");
junk();
}
blanks();
if (!streq(line + lptr, ")")) {
if (!match(","))
error("expected comma");
}
if (endst())
break;
}
if (storage == EXTERN) {
need_semicolon();
return;
}
/* No body .. just a definition */
if (match(";"))
return;
stkp = 0;
argtop = argstk;
while (argstk) {
if ((type = get_type()) != -1) {
notvoid(type);
getarg(type);
need_semicolon();
} else {
error("wrong number args");
break;
}
}
}
if (symbol->offset == FUNCTION)
multidef(n);
symbol->offset = FUNCTION;
output_string(n);
output_label_terminator();
newline();
gen_prologue();
statement(YES);
print_label(fexitlab);
output_label_terminator();
newline();
gen_epilogue();
gen_modify_stack(0);
gen_ret();
stkp = 0;
local_table_index = NUMBER_OF_GLOBALS; //locptr = STARTLOC;
}
/**
* declare local variables
* works just like "declglb", but modifies machine stack and adds
* symbol table entry with appropriate stack offset to find it again
* @param typ
* @param stclass
* @param otag index of tag in tag_table
*/
void declare_local(int typ, int stclass, int otag) {
int k, j;
char sname[NAMESIZE];
FOREVER {
FOREVER {
if (endst())
return;
if (match("*"))
j = POINTER;
else
j = VARIABLE;
if (!symname(sname))
illname();
if (-1 != find_locale(sname))
multidef (sname);
if (match("[")) {
k = needsub();
if (k) {
j = ARRAY;
if (typ & CINT) {
k = k * INTSIZE;
} else if (typ == STRUCT) {
k = k * tag_table[otag].size;
}
} else {
j = POINTER;
k = INTSIZE;
}
} else {
if (j == POINTER) {
k = INTSIZE;
} else {
switch (typ) {
case CCHAR:
case UCHAR:
k = 1;
break;
case STRUCT:
k = tag_table[otag].size;
break;
default:
k = INTSIZE;
}
}
}
if (stclass == LSTATIC) {
add_local(sname, j, typ, k, LSTATIC);
break;
}
if (stclass == REGISTER) {
int r = gen_register(j, k, typ);
if (r != -1) {
add_local(sname, j, typ, r, REGISTER);
break;
}
}
if (match("=")) {
gen_modify_stack(stkp);
expression(0);
gen_push(0);
} else
stkp = gen_defer_modify_stack(stkp - k);
add_local(sname, j, typ, stkp, AUTO);
break;
}
if (!match(","))
return;
}
}
/**
* declare a static variable
* @param type
* @param storage
* @param mtag tag of struct whose members are being declared, or zero
* @param otag tag of struct object being declared. only matters if mtag is non-zero
* @param is_struct struct or union or no meaning
* @return 1 if a function was parsed
*/
int declare_global(int type, int storage, TAG_SYMBOL *mtag, int otag, int is_struct) {
int dim, identity;
char sname[NAMESIZE];
FOREVER {
FOREVER {
if (endst ())
return 0;
dim = 1;
if (match ("*")) {
identity = POINTER;
} else {
identity = VARIABLE;
}
if (!symname (sname))
illname ();
if (match ("(")) {
/* FIXME: We need to deal with pointer types properly here */
if (identity == POINTER)
type = CINT;
newfunc_typed(storage, sname, type);
/* Can't int foo(x){blah),a=4; */
return 1;
}
/* FIXME: we need to deal with extern properly here */
if (find_global (sname) > -1)
multidef (sname);
if (identity == VARIABLE)
notvoid(type);
if (match ("[")) {
dim = needsub ();
//if (dim || storage == EXTERN) {
identity = ARRAY;
//} else {
// identity = POINTER;
//}
}
// add symbol
if (mtag == 0) { // real variable, not a struct/union member
identity = initials(sname, type, identity, dim, otag);
add_global (sname, identity, type, (dim == 0 ? -1 : dim), storage);
if (type == STRUCT) {
symbol_table[current_symbol_table_idx].tagidx = otag;
}
break;
} else if (is_struct) {
// structure member, mtag->size is offset
add_member(sname, identity, type, mtag->size, storage);
// store (correctly scaled) size of member in tag table entry
if (identity == POINTER)
type = CINT;
scale_const(type, otag, &dim);
mtag->size += dim;
}
else {
// union member, offset is always zero
add_member(sname, identity, type, 0, storage);
// store maximum member size in tag table entry
if (identity == POINTER)
type = CINT;
scale_const(type, otag, &dim);
if (mtag->size < dim)
mtag->size = dim;
}
}
if (!match (","))
return 0;
}
}
newfunc ()
{
char n[NAMESIZE], *ptr;
fexitlab = getlabel();
if (!symname (n) ) {
error ("illegal function or declaration");
kill ();
return;
}
if (ptr = findglb (n)) {
if (ptr[IDENT] != FUNCTION)
multidef (n);
else if (ptr[OFFSET] == FUNCTION)
multidef (n);
else
ptr[OFFSET] = FUNCTION;
} else
addglb (n, FUNCTION, CINT, FUNCTION, PUBLIC);
prologue ();
if (!match ("("))
error ("missing open paren");
prefix ();
outstr (n);
col ();
nl ();
locptr = STARTLOC;
argstk = 0;
while (!match (")")) {
if (symname (n)) {
if (findloc (n))
multidef (n);
else {
addloc (n, 0, 0, argstk, AUTO);
argstk = argstk + intsize();
}
} else {
error ("illegal argument name");
junk ();
}
blanks ();
if (!streq (line + lptr, ")")) {
if (!match (","))
error ("expected comma");
}
if (endst ())
break;
}
stkp = 0;
argtop = argstk;
while (argstk) {
if (amatch ("register", 8)) {
if (amatch("char", 4))
getarg(CCHAR);
else if (amatch ("int", 3))
getarg(CINT);
else
getarg(CINT);
ns();
} else if (amatch ("char", 4)) {
getarg (CCHAR);
ns ();
} else if (amatch ("int", 3)) {
getarg (CINT);
ns ();
} else {
error ("wrong number args");
break;
}
}
statement(YES);
printlabel(fexitlab);
col();
nl();
modstk (0);
gret ();
stkp = 0;
locptr = STARTLOC;
}
SYMBOL *
#endif
AddFuncCode(char *n, char type, char ident, char sign,char zfar, int storage, int more, char check,char simple,TAG_SYMBOL *otag, long *addr)
{
unsigned char tvalue; /* Used to hold protot value */
char typ; /* Temporary type */
int itag;
itag=0;
if (otag)
itag=otag-tagtab; /* tag number */
lastst = 0; /* no last statement */
locptr = STARTLOC ; /* deallocate all locals */
fnstart = lineno ; /* remember where fn began */
/*
* Do some elementary checking before hand..
*/
if (zfar && ident!=FUNCTIONP) { zfar=NO; warning(W_FAR); }
if ( ( currfn=findglb(n) ) ) {
/* already in symbol table ? */
if ( currfn->ident != FUNCTION && currfn->ident != FUNCTIONP ) {
/* already variable by that name */
multidef();
}
else if ( currfn->offset.i == FUNCTION && !currfn->prototyped) {
/* already function by that name */
multidef();
}
else {
/* we have what was earlier assumed to be a function */
if (currfn->storage == EXTERNAL && currfn->flags&LIBRARY ) {
/* Overwriting a lib function, is that what you wanted?!? Handy for
* compiling the library though!! Change type to local static to prevent
* being dumped in the scope list..
*/
if (makelib || storage == LSTATIC ) {
currfn->storage=LSTATIC;
} else {
currfn->storage=LIBOVER;
}
currfn->offset.i=FUNCTION;
} else {
/*
* I'm not sure what *exactly* I was trying to achieve here djm 25/2/00
*/
if (currfn->storage != EXTERNAL && ( (currfn->flags&LIBRARY) != LIBRARY) ) {
currfn->flags&=(~LIBRARY);
currfn->size = 0;
}
currfn->offset.i = FUNCTION ;
currfn->storage = storage;
}
}
}
/* if not in table, define as a function now */
else {
typ=type;
if (ident == FUNCTIONP) typ=(zfar ? CPTR : CINT );
currfn = addglb(n, FUNCTION, typ, FUNCTION, storage, more, 0);
currfn->size=0;
currfn->prototyped=0;
currfn->flags= (sign&UNSIGNED) | (zfar&FARPTR);
if (type == STRUCT) currfn->tagarg[0]=itag;
/*
* Set our function prototype - what we are!
* args[0] is free for use
*/
currfn->args[0]=CalcArgValue(type, ident, currfn->flags);
}
tvalue=CalcArgValue(type,ident,((sign&UNSIGNED) | (zfar&FARPTR)) );
if ( currfn->args[0] != tvalue || (type==STRUCT && currfn->tagarg[0] != itag ) ){
char buffer[120];
warning(W_DIFFTYPE);
warning(W_DIFFTYPE2,ExpandArgValue(currfn->args[0],buffer,currfn->tagarg[0]));
warning(W_DIFFTYPE3,ExpandArgValue(tvalue,buffer,itag) );
}
/* we had better see open paren for args... */
if ( check && (cmatch('(') == 0) )
error(E_PAREN);
locptr = STARTLOC ; /* "clear" local symbol table */
undeclared = 0 ; /* init arg count */
/* Check to see if we are doing ANSI fn defs - must be a better way of
* doing this! (Have an array and check by that?)
*/
if (CheckANSI()) {
return( dofnansi(currfn, addr) ); /* So we can pass back result */
}
DoFnKR(currfn,simple);
return(0);
}
/**
* begin a function
* called from "parse", this routine tries to make a function out
* of what follows
* modified version. p.l. woods
*/
newfunc() {
char n[NAMESIZE];
int idx, type;
fexitlab = getlabel();
if (!symname(n)) {
error("illegal function or declaration");
kill();
return;
}
if (idx = findglb(n)) {
if (symbol_table[idx].identity != FUNCTION)
multidef(n);
else if (symbol_table[idx].offset == FUNCTION)
multidef(n);
else
symbol_table[idx].offset = FUNCTION;
} else
add_global(n, FUNCTION, CINT, FUNCTION, PUBLIC);
if (!match("("))
error("missing open paren");
output_string(n);
output_label_terminator();
newline();
local_table_index = NUMBER_OF_GLOBALS; //locptr = STARTLOC;
argstk = 0;
// ANSI style argument declaration
if (doAnsiArguments() == 0) {
// K&R style argument declaration
while (!match(")")) {
if (symname(n)) {
if (findloc(n))
multidef(n);
else {
add_local(n, 0, 0, argstk, AUTO);
argstk = argstk + INTSIZE;
}
} else {
error("illegal argument name");
junk();
}
blanks();
if (!streq(line + lptr, ")")) {
if (!match(","))
error("expected comma");
}
if (endst())
break;
}
stkp = 0;
argtop = argstk;
while (argstk) {
if (type = get_type()) {
getarg(type);
need_semicolon();
} else {
error("wrong number args");
break;
}
}
}
statement(YES);
print_label(fexitlab);
output_label_terminator();
newline();
gen_modify_stack(0);
gen_ret();
stkp = 0;
local_table_index = NUMBER_OF_GLOBALS; //locptr = STARTLOC;
}