/*
* Declare a namespace.
*/
void
dclns(NODE *attr, char *n)
{
struct symtab *sp;
struct attr *ap = gcc_attr_parse(attr);
if (cppdebug)printf("declaring namespace %s\n", n);
n = addname(n);
sp = sfind(n, nscur->sup);
while (sp != NULL) {
if (sp->sname == n && sp->sclass == NSPACE)
break;
sp = sfind(n, sp->snext);
}
if (sp == NULL) {
/* New namespace */
sp = getsymtab(n, 0);
sp->sclass = NSPACE;
INSSYM(sp);
}
nscur = sp;
if (cppdebug)printf("declaring namespace2 %s\n", nscur->sname);
sp->sap = attr_add(sp->sap, ap); /* XXX check attributes */
}
/*
* find a symtab path entry in the given path.
* p is expected to be a link of NMNAMEs.
* It is supposed to return a sup value of the last found class.
*/
static struct symtab *
pfind(NODE *p, struct symtab *sp)
{
char *n;
if (cppdebug)printf("pfind: op %d searching %s\n", p->n_op, p->n_op == NAME ?
(char *)p->n_sp:(char *)p->n_right->n_sp);
if (p->n_op == NAME) {
n = (char *)p->n_sp;
if ((sp = sfind(n, sp)) == NULL)
return NULL;
if (cppdebug)printf("pfind: NAME class %d name %s\n", sp->sclass, sp->sname);
while (!CLORNS(sp)) {
if ((sp = sfind(n, sp->snext)) == NULL)
return NULL;
}
if (cppdebug)printf("pfind: FOUND %s\n", sp->sname);
sp = sp->sup;
} else {
n = (char *)p->n_right->n_sp;
if ((sp = sfind(n, sp)) == NULL)
return NULL;
if (cppdebug)printf("pfind: NMLIST class %d name %s\n", sp->sclass, sp->sname);
while (!CLORNS(sp)) {
if ((sp = sfind(n, sp->snext)) == NULL)
return NULL;
}
sp = pfind(p->n_left, sp->sup);
}
return sp;
}
// Delete a screen. Return status.
int deleteScreen(Value *rp,int n) {
EScreen *scrp;
// Get the number of the screen to delete.
if(n == INT_MIN && !getnum(text243,&n))
// "Delete screen"
return rc.status;
// Make sure it exists.
if(!sfind((ushort) n,NULL,&scrp))
return rcset(FAILURE,0,text240,n);
// "No such screen '%d'"
// It can't be current.
if(scrp == cursp)
return rcset(FAILURE,0,text241);
// "Screen is being displayed"
// Everything's cool ... nuke it.
if(unlistscreen(scrp) != SUCCESS)
return rc.status;
freescreen(scrp);
return rcset(SUCCESS,0,text178,n);
// "Deleted screen %d"
}
/*
* Declare a struct (class) based on its name n.
* Assumed that nmcur is correctly pointing to either:
* - nothing (class at level 0)
* - current namespace
* - parent class
*/
struct symtab *
cxxdclstr(char *n)
{
struct symtab *sp;
sp = sfind(n, nscur->sup);
while (sp && !CLORNS(sp))
sp = sfind(n, sp->snext);
if (sp == 0)
sp = getsymtab(n, STAGNAME);
// else
// uerror("class/namespace redefined");
// INSSYM(sp);
// nscur = sp;
if (cppdebug)printf("declaring2 struct %s %p nscur %s\n", n, sp, nscur->sname);
return sp;
}
/*
* Watch out for references to static members.
*/
NODE *
cxxstructref(NODE *p, int f, char *n)
{
struct symtab *sp = strmemb(p->n_ap);
if (sp == NULL)
cerror("ref to unknown struct");
sp = sfind(n, sp);
while (sp != NULL) {
if (ISFTN(sp->stype) == 0) {
if (sp->sclass == STATIC || sp->sclass == USTATIC) {
tfree(p);
return nametree(sp);
}
break;
}
sp = sfind(n, sp->snext);
}
return structref(p, f, n);
}
/*
* Reference to a struct as a :: name.
*/
NODE *
cxxrstruct(int soru, NODE *attr, NODE *t, char *n)
{
struct symtab *ns, *sp;
ns = pfind(t, spole->sup);
if (ns == NULL)
goto undecl;
tfree(t);
sp = sfind(n, ns);
while (sp != NULL) {
if (sp->sclass == soru)
return mkty(sp->stype, 0, sp->sap);
sp = sfind(n, sp->snext);
}
undecl:
uerror("%s undeclared", n);
return mkty(INT, 0, 0);
}
// Create new screen, switch to it, and return its number. Return status.
int newScreen(Value *rp,int n) {
EScreen *scrp;
// Save the current window's settings.
wftobf(curwp,curbp);
// Find screen "0" to force-create one and make it current.
if(sfind(0,curbp,&scrp) != SUCCESS || sswitch(scrp) != SUCCESS)
return rc.status;
vsetint((long) scrp->s_num,rp);
return rcset(SUCCESS,0,text174,scrp->s_num);
// "Created screen %hu"
}
/*
* Search for correct matching function in a struct depending on
* argument list a. Return a call node for this function.
* Do not touch neither f nor a.
* return a name tree suitable for a function call.
* We know here that f is a struct reference.
*/
NODE *
cxxmatchftn(NODE *f, NODE *a)
{
struct attr *ap;
struct symtab *sp;
char *n = (char *)f->n_right->n_sp;
f = f->n_left;
if ((ap = attr_find(f->n_ap, ATTR_STRUCT)) == NULL) {
uerror("undefined class");
sp = getsymtab(n, 0);
} else
sp = ap->amlist;
sp = sfind(n, sp);
while (sp != NULL) {
if (ISFTN(sp->stype) && cxxptreecmp(sp, a) == 0)
break;
sp = sfind(n, sp->snext);
}
if (sp == NULL)
uerror("undefined class member");
return nametree(sp);
}
String sformat(const String &p_text, const Variant &p1, const Variant &p2, const Variant &p3, const Variant &p4, const Variant &p5) {
if (p_text.length() < 2)
return p_text;
Array args;
if (p1.get_type() != Variant::NIL) {
args.push_back(p1);
if (p2.get_type() != Variant::NIL) {
args.push_back(p2);
if (p3.get_type() != Variant::NIL) {
args.push_back(p3);
if (p4.get_type() != Variant::NIL) {
args.push_back(p4);
if (p5.get_type() != Variant::NIL) {
args.push_back(p5);
}
}
}
}
}
String new_string;
int findex = 0;
int search_from = 0;
int result = 0;
while ((result = sfind(p_text, search_from)) >= 0) {
CharType c = p_text[result + 1];
int req_index = (c == 's' ? findex++ : c - '0');
new_string += p_text.substr(search_from, result - search_from);
new_string += args[req_index].operator String();
search_from = result + 2;
}
new_string += p_text.substr(search_from, p_text.length() - search_from);
return new_string;
}
/*
* Search for (and declare) a function.
*/
struct symtab *
cxxftnfind(NODE *p, int flags)
{
struct symtab *sp, *ns;
char *s;
if (p->n_op == NAME) {
s = (char *)p->n_sp;
/* Search for equally named functions */
sp = sfind(s, nscur->sup);
while (sp != NULL) {
if (cxxpcmp(sp, p)) {
if (sp->sclass != NSPACE ||
sp->sclass == EXTDEF) {
uerror("%s redefined", s);
return sp;
} else
break;
}
sp = sfind(s, sp->snext);
}
if (sp == NULL) {
sp = getsymtab(s, SNORMAL);
sp->stype = p->n_type;
sp->squal = p->n_qual;
sp->sdf = p->n_df;
sp->sap = p->n_ap;
INSSYM(sp);
if (nscur->sclass != NSPACE && nscur != &spole0)
uerror("inside struct");
}
sp->sclass = EXTDEF;
if (sp->soname == 0)
sp->soname = decoratename(sp, NM_NORMAL);
} else {
/*
* declared outside class, tree-style reference
* Must have been defined already
* This will be an external declaration (not spooled).
*/
s = SPNAME(p);
if ((ns = pfind(p->n_left, spole->sup)) == NULL) {
uerror("undeclared class in chain");
goto undecl;
}
/* Search for an EXTERN or EXTDEF declaration within */
/* EXTDEF causes redeclaration. */
sp = sfind(s, ns);
while (sp != NULL) {
if (sp->sclass == EXTERN || sp->sclass == EXTDEF) {
if (cxxpcmp(sp, p->n_right)) {
if (sp->sclass == EXTDEF)
uerror("%s redefined", s);
break;
}
}
sp = sfind(s, sp->snext);
}
if (sp == NULL) {
uerror("%s undeclared", s);
goto undecl;
}
sp->sclass = EXTDEF;
}
return sp;
undecl:
return getsymtab(s, SNORMAL);
}
/*
* Do a name lookup. p can be either just a NAME or NMLIST.
* The first symbol instance on its level is returned, which may or
* may not be correct.
* If no symbol is found, return a new symtab entry.
* p should be a NAME after this with n_sp filled in accordingly.
* It's the responsibility of the declaration routine to add it to
* the symbol table.
* nfree() will be called on p after this function.
*/
struct symtab *
cxxlookup(NODE *p, int flags)
{
struct symtab *sp, *ns;
int ftyp = flags & SMASK;
NODE *q;
char *n, *s;
#define SPNAME(p) ((char *)(p->n_op == NAME ? p->n_sp : p->n_right->n_sp))
if (cppdebug){ printf("cxxlookup %s\n", SPNAME(p)); symtree(); }
q = p;
if (p->n_op == NAME) {
s = (char *)p->n_sp;
if (blevel) {
sp = lookup(s, SNOCREAT); /* check if auto var */
if (sp == NULL) {
/* check if in classes */
for (ns = nscur; ns != spole; ns = ns->sdown)
if ((sp = sfind(s, ns->sup)))
break;
if (sp == NULL)
sp = sfind(s, spole->sup);
}
if (sp == NULL)
sp = lookup(s, 0); /* fallback */
} else {
ns = nscur;
sp = sfind(s, ns);
while (sp != NULL) {
if ((sp->sflags & SMASK) == ftyp)
break;
sp = sfind(s, sp->snext);
}
if (sp == NULL) {
sp = getsymtab(s, ftyp);
if ((flags & SNOCREAT) == 0) {
if (cppdebug)printf("cxxlookup: adding %s %s %s at %s\n", symclass[ftyp], s, sp->soname, nscur ? nscur->sname : "base");
INSSYM(sp);
cxxsetname(sp);
}
}
}
} else {
/* Search through namespaces/classes for it */
n = SPNAME(p);
ns = pfind(p->n_left, spole->sup);
if (ns == NULL) {
uerror("undeclared class in chain");
return getsymtab(n, ftyp);
}
if ((sp = sfind(n, ns)) == NULL) {
sp = getsymtab(n, ftyp);
if ((flags & SNOCREAT) == 0) {
sp->snext = ns->snext;
ns->snext = sp;
}
}
}
/* make top node a NAME */
if (q->n_op != NAME) {
tfree(q->n_left);
p = q->n_right;
*q = *q->n_right;
nfree(p);
}
q->n_sp = sp;
return sp;
}