void AstVarXRef::dump(ostream& str) {
this->AstNode::dump(str);
if (lvalue()) str<<" [LV] => ";
else str<<" [RV] <- ";
str<<dotted()<<". - ";
if (inlinedDots()!="") str<<" flat.="<<inlinedDots()<<" - ";
if (varScopep()) { varScopep()->dump(str); }
else if (varp()) { varp()->dump(str); }
else { str<<"UNLINKED"; }
}
LLVMValueRef gen_assign(struct node *ast)
{
LLVMValueRef result;
result = codegen(ast->two);
/* TODO: Forbid assignment to labels */
check_store(result, lvalue(ast->one));
return result;
}
TypeSpec
ASTstructselect::typecheck (TypeSpec expected)
{
// The ctr already figured out if this was a valid structure selection
if (m_fieldid < 0 || m_mangledsym == NULL)
return TypeSpec();
typecheck_children ();
StructSpec *structspec (TypeSpec::structspec (m_structid));
m_typespec = structspec->field(m_fieldid).type;
m_is_lvalue = lvalue()->is_lvalue();
return m_typespec;
}
LLVMValueRef gen_predec(struct node *ast)
{
LLVMValueRef result;
result = LLVMBuildSub(builder,
codegen(ast->one),
CONST(1),
"");
check_store(result, lvalue(ast->one));
return result;
}
Tree asgntree(int op, Tree l, Tree r) {
Type aty, ty;
r = pointer(r);
ty = assign(l->type, r);
if (ty)
r = cast(r, ty);
else {
typeerror(ASGN, l, r);
if (r->type == voidtype)
r = retype(r, inttype);
ty = r->type;
}
if (l->op != FIELD)
l = lvalue(l);
aty = l->type;
if (isptr(aty))
aty = unqual(aty)->type;
if (isconst(aty)
|| (isstruct(aty) && unqual(aty)->u.sym->u.s.cfields)) {
if (isaddrop(l->op)
&& !l->u.sym->computed && !l->u.sym->generated)
error("assignment to const identifier `%s'\n",
l->u.sym->name);
else
error("assignment to const location\n");
}
if (l->op == FIELD) {
long n = 8 * l->u.field->type->size - fieldsize(l->u.field);
if (n > 0 && isunsigned(l->u.field->type))
r = bittree(BAND, r,
cnsttree(r->type, (unsigned long)fieldmask(l->u.field)));
else if (n > 0) {
if (r->op == CNST + I) {
n = r->u.v.i;
if (n & (1 << (fieldsize(l->u.field) - 1)))
n |= ~0UL << fieldsize(l->u.field);
r = cnsttree(r->type, n);
} else
r = shtree(RSH,
shtree(LSH, r, cnsttree(inttype, n)),
cnsttree(inttype, n));
}
}
if (isstruct(ty) && isaddrop(l->op) && iscallb(r))
return tree(RIGHT, ty,
tree(CALL + B, ty, r->kids[0]->kids[0], l),
idtree(l->u.sym));
return tree(mkop(op, ty), ty, l, r);
}
LLVMValueRef gen_postdec(struct node *ast)
{
LLVMValueRef orig, result;
orig = codegen(ast->one);
result = LLVMBuildSub(builder,
orig,
CONST(1),
"");
check_store(result, lvalue(ast->one));
return orig;
}
static int
attribute_cntl_a_sequences(void)
{
BUFFER *bp = curbp;
LINE *pastline;
C_NUM offset; /* offset in cur line of place to attribute */
int count;
#if EFFICIENCY_HACK
AREGION *orig_attribs = bp->b_attribs;
AREGION *new_attribs;
#endif
if ((pastline = setup_region()) == 0)
return FALSE;
while (DOT.l != pastline) {
if (interrupted())
return FALSE;
while (DOT.o < llength(DOT.l)) {
if (CharAtDot() == CONTROL_A) {
offset = decode_attribute(lvalue(DOT.l),
(size_t) llength(DOT.l),
(size_t) DOT.o, &count);
if (offset > DOT.o) {
#if EFFICIENCY_HACK
new_attribs = bp->b_attribs;
bp->b_attribs = orig_attribs;
ldel_bytes((B_COUNT) (offset - DOT.o), FALSE);
bp->b_attribs = new_attribs;
#else
ldel_bytes((B_COUNT) (offset - DOT.o), FALSE);
#endif
}
set_mark_after(count, len_record_sep(bp));
if (apply_attribute())
(void) attributeregion();
} else {
DOT.o += BytesAt(DOT.l, DOT.o);
}
}
DOT.l = lforw(DOT.l);
DOT.o = 0;
}
return TRUE;
}
const String SAX2AttributesImpl::getValue(
const String & uri,
const String & localPart ) const
{
unsigned int i;
unsigned int size = (unsigned int)attrs.size();
for(i = 0;i < size; i++)
{
String lattruri( Unmarshaller::newString( attrs[i].uri ) );
String llocalname( Unmarshaller::newString( attrs[i].localname ) );
if((uri == lattruri) && (localPart == llocalname))
{
String lvalue( Unmarshaller::newString( attrs[i].value ) );
return lvalue;
}
}
return "";
}
static int
testit(LINE *lp, regexp * exp, int *end, int srchlim)
{
char *txt = lvalue(lp);
C_NUM col = (C_NUM) (exp->startp[0] - txt) + 1;
if (col > llength(lp))
col = llength(lp);
if (lregexec(exp, lp, col, srchlim)) {
col = (C_NUM) (exp->startp[0] - txt) + 1;
if (col > llength(lp) && !*end) {
col = llength(lp);
*end = TRUE;
}
if (col <= srchlim)
return TRUE;
}
return FALSE;
}
/* entry_hook - called an function entry */
static void entry_hook(void *cl, Symbol cfunc) {
static int nfuncs;
Type ty;
/*
Simulate the declaration of an sframe structure,
but without the tag.
*/
ty = newstruct(STRUCT, "");
#define addfield(name,t) \
ty->size = roundup(ty->size, t->align);\
if (ty->align < t->align) ty->align = t->align; \
newfield(string(name), ty, t)->offset = ty->size; \
ty->size += t->size
addfield("up", voidptype);
addfield("down", voidptype);
addfield("func", inttype);
addfield("module",inttype);
addfield("ip", inttype);
#undef addfield
ty->size = roundup(ty->size, ty->align);
ty->u.sym->defined = 1;
ty->u.sym->generated = 1;
tos = genident(AUTO, ty, LOCAL);
addlocal(tos);
tos->defined = 1;
/*
Generated the assignments to the shadow
frame fields.
*/
#define set(name,e) walk(asgntree(ASGN,field(lvalue(idtree(tos)),string(#name)),(e)),0,0)
set(down, idtree(nub_tos));
set(func, cnsttree(inttype, symboluid(cfunc)));
set(module, cnsttree(inttype, uname));
#undef set
walk(asgn(nub_tos, lvalue(idtree(tos))), 0, 0);
foreach(identifiers, PARAM, setoffset, tos);
}
Tree unary(void) {
Tree p;
switch (t) {
case '*': t = gettok(); p = unary(); p = pointer(p);
if (isptr(p->type)
&& (isfunc(p->type->type) || isarray(p->type->type)))
p = retype(p, p->type->type);
else {
if (YYnull)
p = nullcheck(p);
p = rvalue(p);
} break;
case '&': t = gettok(); p = unary(); if (isarray(p->type) || isfunc(p->type))
p = retype(p, ptr(p->type));
else
p = lvalue(p);
if (isaddrop(p->op) && p->u.sym->sclass == REGISTER)
error("invalid operand of unary &; `%s' is declared register\n", p->u.sym->name);
else if (isaddrop(p->op))
p->u.sym->addressed = 1;
break;
case '+': t = gettok(); p = unary(); p = pointer(p);
if (isarith(p->type))
p = cast(p, promote(p->type));
else
typeerror(ADD, p, NULL); break;
case '-': t = gettok(); p = unary(); p = pointer(p);
if (isarith(p->type)) {
Type ty = promote(p->type);
p = cast(p, ty);
if (isunsigned(ty)) {
warning("unsigned operand of unary -\n");
p = simplify(ADD, ty, simplify(BCOM, ty, p, NULL), cnsttree(ty, 1UL));
} else
p = simplify(NEG, ty, p, NULL);
} else
typeerror(SUB, p, NULL); break;
case '~': t = gettok(); p = unary(); p = pointer(p);
if (isint(p->type)) {
Type ty = promote(p->type);
p = simplify(BCOM, ty, cast(p, ty), NULL);
} else
typeerror(BCOM, p, NULL); break;
case '!': t = gettok(); p = unary(); p = pointer(p);
if (isscalar(p->type))
p = simplify(NOT, inttype, cond(p), NULL);
else
typeerror(NOT, p, NULL); break;
case INCR: t = gettok(); p = unary(); p = incr(INCR, pointer(p), consttree(1, inttype)); break;
case DECR: t = gettok(); p = unary(); p = incr(DECR, pointer(p), consttree(1, inttype)); break;
case TYPECODE: case SIZEOF: { int op = t;
Type ty;
p = NULL;
t = gettok();
if (t == '(') {
t = gettok();
if (istypename(t, tsym)) {
ty = typename();
expect(')');
} else {
p = postfix(expr(')'));
ty = p->type;
}
} else {
/*
* scanner -- Search for a pattern in either direction. can optionally
* wrap around end of buffer.
*/
int
scanner(
regexp * exp, /* the compiled expression */
int direct, /* up or down */
int wrapok, /* ok to wrap around end of buffer? */
int *wrappedp)
{
MARK curpos;
int found;
int wrapped = FALSE;
int leftmargin = b_left_margin(curbp);
TRACE((T_CALLED "scanner %s %s\n",
((direct == FORWARD) ? "forward" : "backward"),
(wrapok ? "wrapok" : "nowrapok")));
if (!exp) {
mlforce("BUG: null exp");
returnCode(FALSE);
}
/* Set starting search position to current position
*/
curpos = DOT;
if (curpos.o < leftmargin)
curpos.o = leftmargin;
/* Scan each character until we hit the scan boundary */
for_ever {
int startoff, srchlim;
if (interrupted()) {
if (wrappedp)
*wrappedp = wrapped;
returnCode(ABORT);
}
if (sameline(curpos, scanboundpos)) {
if (scanbound_is_header) {
/* if we're on the header, nothing can match */
found = FALSE;
srchlim = leftmargin;
} else {
if (direct == FORWARD) {
if (wrapped) {
startoff = curpos.o;
srchlim = scanboundpos.o;
} else {
startoff = curpos.o;
srchlim = ((scanboundpos.o > startoff)
? scanboundpos.o
: llength(curpos.l));
}
} else {
if (wrapped) {
startoff = scanboundpos.o;
srchlim = llength(curpos.l);
} else {
startoff = leftmargin;
srchlim = scanboundpos.o + 1;
}
}
found = lregexec(exp, curpos.l, startoff, srchlim);
}
} else {
if (direct == FORWARD) {
startoff = curpos.o;
srchlim = llength(curpos.l);
} else {
startoff = leftmargin;
srchlim = curpos.o + 1;
if (srchlim > llength(curpos.l))
srchlim = llength(curpos.l);
}
found = lregexec(exp, curpos.l, startoff, srchlim);
}
if (found) {
char *txt = lvalue(curpos.l);
char *got = exp->startp[0];
C_NUM next;
C_NUM last = curpos.o;
if (direct == REVERSE) { /* find the last one */
int end = FALSE;
char *tst = 0;
last++;
while (testit(curpos.l, exp, &end, srchlim)) {
got = exp->startp[0];
/* guard against infinite loop: "?$"
* or "?.*"
*/
if (tst == got)
break;
tst = got;
}
if (end)
last++;
if (!lregexec(exp, curpos.l, (int) (got - txt), srchlim)) {
mlforce("BUG: prev. match no good");
returnCode(FALSE);
}
} else if (llength(curpos.l) <= leftmargin
|| last < llength(curpos.l)) {
last--;
}
next = (C_NUM) (got - txt);
if (next != last) {
DOT.l = curpos.l;
DOT.o = next;
curwp->w_flag |= WFMOVE; /* flag that we have moved */
if (wrappedp)
*wrappedp = wrapped;
#if OPT_TRACE
trace_mark("...scanner", &DOT, curbp);
#endif
returnCode(TRUE);
}
} else {
if (sameline(curpos, scanboundpos) &&
(!wrapok || wrapped))
break;
}
if (direct == FORWARD) {
curpos.l = lforw(curpos.l);
} else {
curpos.l = lback(curpos.l);
}
if (is_header_line(curpos, curbp)) {
wrapped = TRUE;
if (sameline(curpos, scanboundpos) &&
(!wrapok || wrapped))
break;
if (direct == FORWARD)
curpos.l = lforw(curpos.l);
else
curpos.l = lback(curpos.l);
}
if (direct == FORWARD) {
curpos.o = leftmargin;
} else {
if ((curpos.o = llength(curpos.l) - 1) < leftmargin)
curpos.o = leftmargin;
}
}
if (wrappedp)
*wrappedp = wrapped;
returnCode(FALSE); /* We could not find a match. */
}
Tree call(Tree f, Type fty, Coordinate src) {
int n = 0;
Tree args = NULL, r = NULL, e;
Type *proto, rty = unqual(freturn(fty));
Symbol t3 = NULL;
if (fty->u.f.oldstyle)
proto = NULL;
else
proto = fty->u.f.proto;
if (hascall(f))
r = f;
if (isstruct(rty))
{
t3 = temporary(AUTO, unqual(rty));
if (rty->size == 0)
error("illegal use of incomplete type `%t'\n", rty);
}
if (t != ')')
for (;;) {
Tree q = pointer(expr1(0));
if (proto && *proto && *proto != voidtype)
{
Type aty;
q = value(q);
aty = assign(*proto, q);
if (aty)
q = cast(q, aty);
else
error("type error in argument %d to %s; found `%t' expected `%t'\n", n + 1, funcname(f),
q->type, *proto);
if ((isint(q->type) || isenum(q->type))
&& q->type->size != inttype->size)
q = cast(q, promote(q->type));
++proto;
}
else
{
if (!fty->u.f.oldstyle && *proto == NULL)
error("too many arguments to %s\n", funcname(f));
q = value(q);
if (isarray(q->type) || q->type->size == 0)
error("type error in argument %d to %s; `%t' is illegal\n", n + 1, funcname(f), q->type);
else
q = cast(q, promote(q->type));
}
if (!IR->wants_argb && isstruct(q->type))
if (iscallb(q))
q = addrof(q);
else {
Symbol t1 = temporary(AUTO, unqual(q->type));
q = asgn(t1, q);
q = tree(RIGHT, ptr(t1->type),
root(q), lvalue(idtree(t1)));
}
if (q->type->size == 0)
q->type = inttype;
if (hascall(q))
r = r ? tree(RIGHT, voidtype, r, q) : q;
args = tree(mkop(ARG, q->type), q->type, q, args);
n++;
if (Aflag >= 2 && n == 32)
warning("more than 31 arguments in a call to %s\n",
funcname(f));
if (t != ',')
break;
t = gettok();
}
expect(')');
if (proto && *proto && *proto != voidtype)
error("insufficient number of arguments to %s\n",
funcname(f));
if (r)
args = tree(RIGHT, voidtype, r, args);
e = calltree(f, rty, args, t3);
if (events.calls)
apply(events.calls, &src, &e);
return e;
}
void allocate(int datareg, int addreg, int floatreg, SNODE *block)
/*
* allocate will allocate registers for the expressions that have
* a high enough desirability. It also puts the function
* header, consisting of saved registers and stack decrments for local
* variables
*/
{
CSE *csp;
ENODE *exptr;
unsigned mask, rmask, i, fmask, frmask, size;
AMODE *ap, *ap2;
mask = asmMask;
rmask = asmRMask;
fmask = frmask = 0;
for (i = cf_freedata; i < datareg; i++)
{
rmask = rmask | (1 << (15-i));
mask = mask | (1 << i);
}
for (i = cf_freeaddress + 16; i < addreg; i++)
{
rmask = rmask | (1 << (23-i));
mask = mask | (1 << (i - 8));
}
while (bsort(&olist))
;
/* sort the expression list */
csp = olist;
while (csp != 0)
{
if (csp->reg == - 1 && !(csp->exp->cflags &DF_VOL) && !csp->voidf)
{
if (desire(csp) < 3)
csp->reg = - 1;
else
{
if (csp->exp->nodetype == en_rcon || csp->exp->nodetype ==
en_fcon || csp->exp->nodetype == en_lrcon || csp->exp
->nodetype == en_floatref || csp->exp->nodetype ==
en_doubleref || csp->exp->nodetype == en_longdoubleref ||
csp->exp->nodetype == en_fimaginarycon ||
csp->exp->nodetype == en_rimaginarycon ||
csp->exp->nodetype == en_lrimaginarycon ||
csp->exp->nodetype == en_fimaginaryref ||
csp->exp->nodetype == en_rimaginaryref ||
csp->exp->nodetype == en_lrimaginaryref) {}
else if ((csp->duses <= csp->uses / 4) && (datareg < cf_maxdata)
&& dataregs)
csp->reg = (datareg)++;
else if (!(csp->size == 1 || csp->size == - 1 || csp->size ==
5) && (addreg < cf_maxaddress) && addrregs)
csp->reg = (addreg)++;
else if ((datareg < cf_maxdata) && dataregs)
csp->reg = (datareg)++;
if (csp->reg != - 1)
// if (lvalue(csp->exp))
// csp->seg = defseg(csp->exp->v.p[0]) ;
// else
if (!csp->seg)
{
csp->seg = defseg(csp->exp);
if (csp->seg)
csp->reg = -1;
}
}
}
if (csp->reg != - 1)
{
if (lvalue(csp->exp) && !((SYM*)csp->exp->v.p[0]->v.p[0])->funcparm)
{
((SYM*)csp->exp->v.p[0]->v.p[0])->mainsym->inreg = TRUE;
((SYM*)csp->exp->v.p[0]->v.p[0])->mainsym->value.i = - csp
->reg - (csp->size < 0 ? - csp->size: csp->size) *256;
}
if (csp->reg < 16)
{
rmask = rmask | (1 << (15-csp->reg));
mask = mask | (1 << csp->reg);
}
if (csp->reg < 32)
{
rmask = rmask | (1 << (23-csp->reg));
mask = mask | (1 << (csp->reg - 8));
}
else
{
frmask = frmask | (1 << (39-csp->reg));
fmask = fmask | (1 << (csp->reg - 32));
}
}
csp = csp->next;
}
allocstack(); /* Allocate stack space for the local vars */
floatstack_mode = 0; /* no space for floating point temps */
if (currentfunc->intflag || currentfunc->faultflag)
{
mask = 0;
rmask = 0;
if (currentfunc->loadds)
loadds();
if (prm_farkeyword)
{
GenPush(ES + 24, am_dreg, 0);
GenPush(FS + 24, am_dreg, 0);
GenPush(GS + 24, am_dreg, 0);
}
gen_code(op_pushad, 0, 0);
}
if ((conscount || try_block_list || currentfunc->value.classdata.throwlist
&& currentfunc->value.classdata.throwlist->data) && prm_xcept)
{
xceptoffs = lc_maxauto += sizeof(XCEPTDATA);
}
if (prm_debug)
{
rmask = rmask | (1 << (15-EBX));
mask = mask | (1 << EBX);
rmask = rmask | (1 << (15-ESI-4));
mask = mask | (1 << (ESI+4));
rmask = rmask | (1 << (15-EDI-4));
mask = mask | (1 << (EDI+4));
}
if (prm_cplusplus && prm_xcept || (funcfloat || lc_maxauto || currentfunc
->tp->lst.head && currentfunc->tp->lst.head != (SYM*) - 1)
|| (currentfunc->value.classdata.cppflags &PF_MEMBER) && !(currentfunc
->value.classdata.cppflags &PF_STATIC)
|| !prm_smartframes || !stackframeoff)
{
/* enter is *really* inefficient so we will not use it */
if (!currentfunc->intflag)
gen_codes(op_push, 4, makedreg(EBP), 0);
gen_codes(op_mov, 4, makedreg(EBP), makedreg(ESP));
if (lc_maxauto)
gen_code(op_sub, makedreg(ESP), make_immed(lc_maxauto));
// FIXME ... could auto-alloc an FP value when no frame!
frame_ins = peep_tail;
}
else
frame_ins = 0;
if (mask != 0)
PushRegs(rmask);
save_mask = mask;
if (fmask != 0)
fsave_mask = fmask;
if (currentfunc->loadds && !currentfunc->intflag)
{
loadds();
}
if (prm_stackcheck && lc_maxauto)
{
AMODE *ap1;
ap = set_symbol("__stackerror", 1);
ap1 = set_symbol("__stackbottom", 0);
ap1->mode = am_direct;
gen_codes(op_cmp, 4, makedreg(ESP), ap1);
gen_codes(op_jb, 0, ap, 0);
}
AddProfilerData();
if ((conscount || try_block_list || currentfunc->value.classdata.throwlist
&& currentfunc->value.classdata.throwlist->data) && prm_xcept)
{
currentfunc->value.classdata.conslabel = nextlabel++;
currentfunc->value.classdata.destlabel = nextlabel++;
gen_codes(op_mov, 4, makedreg(EAX), make_label(nextlabel - 2));
call_library("__InitExceptBlock");
gen_label(nextlabel - 1);
}
}
static char * mangleExpressionInternal (char *buf, EXPRESSION *exp)
{
while (castvalue(exp))
exp = exp->left;
if (isintconst(exp))
{
if (exp->type == en_const)
{
sprintf(buf, "%lld&", exp->v.sp->value.i);
}
else
{
sprintf(buf, "%lld&", exp->v.i);
}
if (buf[0] == '-')
buf[0] = '_';
}
else
{
BOOLEAN nonpointer = FALSE;
while (lvalue(exp))
{
nonpointer = TRUE;
exp = exp->left;
}
switch (exp->type)
{
case en_nullptr:
*buf++ = 'n';
*buf = 0;
break;
case en_arrayadd:
case en_structadd:
case en_add:
*buf++ = 'p';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_sub:
*buf++ = 's';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_mul:
case en_umul:
case en_arraymul:
*buf++ = 'm';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_umod:
case en_mod:
*buf++ = 'o';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_div:
case en_udiv:
case en_arraydiv:
*buf++ = 'd';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_lsh:
case en_arraylsh:
*buf++ = 'h';
*buf++ = 'l';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_rsh:
case en_ursh:
*buf++ = 'h';
*buf++ = 'r';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_cond:
*buf++ = 'C';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right->left);
buf = mangleExpressionInternal(buf, exp->right->right);
*buf = 0;
break;
case en_assign:
*buf++ = 'a';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_eq:
*buf++ = 'c';
*buf++ = 'e';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ne:
*buf++ = 'c';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_uminus:
*buf++ = 'u';
buf = mangleExpressionInternal(buf, exp->left);
break;
case en_not:
*buf++ = 'l';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
break;
case en_compl:
*buf++ = 'b';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
*buf = 0;
break;
case en_ascompl:
*buf++ = 'a';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ult:
case en_lt:
*buf++ = 'c';
*buf++ = 'l';
*buf++ = 't';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ule:
case en_le:
*buf++ = 'c';
*buf++ = 'l';
*buf++ = 'e';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ugt:
case en_gt:
*buf++ = 'c';
*buf++ = 'g';
*buf++ = 't';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_uge:
case en_ge:
*buf++ = 'c';
*buf++ = 'g';
*buf++ = 'e';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_and:
*buf++ = 'b';
*buf++ = 'a';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_land:
*buf++ = 'l';
*buf++ = 'a';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_or:
*buf++ = 'b';
*buf++ = 'o';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_lor:
*buf++ = 'l';
*buf++ = 'o';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_xor:
*buf++ = 'b';
*buf++ = 'x';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_autoinc:
*buf++ = 'i';
*buf++ = 'p';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_autodec:
*buf++ = 'i';
*buf++ = 's';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_templateselector:
{
TEMPLATESELECTOR *tsl = exp->v.templateSelector, *find = tsl->next->next;
SYMBOL *ts = tsl->next->sym;
*buf++ = 't';
*buf++ = 's';
if (tsl->next->isTemplate && tsl->next->templateParams) // may be an empty variadic
{
buf = mangleTemplate(buf, ts, tsl->next->templateParams);
}
while (find)
{
*buf++ = 't';
buf = lookupName(buf, find->name);
find = find->next;
}
*buf = 0;
break;
}
case en_templateparam:
*buf++ = 't';
*buf++ = 'p';
buf = lookupName(buf,exp->v.sp->name);
*buf = 0;
break;
case en_funcret:
buf = mangleExpressionInternal(buf, exp->left);
*buf = 0;
break;
case en_func:
if (exp->v.func->ascall)
{
INITLIST *args = exp->v.func->arguments;
*buf++ = 'f';
buf = lookupName(buf, exp->v.func->sp->name);
while(args)
{
*buf++='f';
buf = mangleExpressionInternal(buf, args->exp);
args = args->next;
}
}
else
{
*buf++ = 'e';
*buf++ = '&';
strcpy(buf, exp->v.func->sp->name);
buf += strlen(buf);
*buf++ = '$';
buf = mangleType( buf, exp->v.func->sp->tp, TRUE);
}
break;
case en_pc:
case en_global:
case en_label:
case en_const:
if (isfunction(exp->v.sp->tp))
{
*buf++ = 'e';
*buf++ = '&';
strcpy(buf, exp->v.sp->name);
buf += strlen(buf);
*buf++ = '$';
buf = mangleType( buf, exp->v.sp->tp, TRUE);
}
else
{
*buf++ = 'g';
if (!nonpointer)
*buf++ = '&';
strcpy(buf, exp->v.sp->name);
*buf++ = '$';
*buf = 0;
}
break;
default:
*buf = 0;
break;
}
}
buf += strlen(buf);
return buf;
}
void loadregs(void)
/*
* Initailze allocated regs
*
*/
{ CSE *csp;
ENODE *exptr;
unsigned mask, rmask,i,fmask,frmask,size;
AMODE *ap, *ap2;
csp = olist;
while( csp != 0 ) {
int sz;
if( csp->reg != -1 )
{ /* see if preload needed */
exptr = csp->exp;
if( !lvalue(exptr) || ((SYM *)exptr->v.p[0]->v.p[0])->funcparm )
{
exptr = csp->exp;
initstack();
sz = csp->size;
ap = gen_expr(exptr,F_ALL,sz);
if (sz == 0 && ap->mode == am_immed)
sz = 4;
if( csp->reg < 16 ) {
if (sz == 0 && ap->mode == am_immed)
sz = 4;
if (ap->mode == am_dreg)
peep_tail->oper2->preg = csp->reg;
else {
ap2 = makedreg(csp->reg);
gen_code(op_move,sz,ap,ap2);
do_extend(ap2,sz,4,F_DREG);
}
}
else
if (csp->reg < 32) {
if (sz == 0 && ap->mode == am_immed)
sz = 4;
if (ap->mode == am_areg)
peep_tail->oper2->preg = csp->reg - 16;
else {
ap2 = makeareg(csp->reg - 16);
gen_code(op_move,4,ap,ap2);
}
}
else {
if (sz == 0 && ap->mode == am_immed)
sz = 8;
if (ap->mode == am_freg)
peep_tail->oper2->preg = csp->reg - 32;
else {
ap2 = makefreg(csp->reg - 32);
size = 8;
if (exptr->nodetype == en_floatref)
size = 6;
gen_code(op_fmove,size,ap,ap2);
}
}
freeop(ap);
if (lvalue(exptr) && ((SYM *)exptr->v.p[0]->v.p[0])->funcparm) {
((SYM *)exptr->v.p[0]->v.p[0])->inreg = TRUE;
((SYM *)exptr->v.p[0]->v.p[0])->value.i = -csp->reg;
}
}
}
csp = csp->next;
}
}
void loadregs(void)
/*
* initialize allocated registers
*/
{
CSE *csp;
ENODE *exptr;
unsigned mask, rmask, i, fmask, frmask, size;
AMODE *ap, *ap2;
csp = olist;
while (csp != 0)
{
int sz;
if (csp->reg != - 1)
{
/* see if preload needed */
exptr = csp->exp;
if (!lvalue(exptr) || ((SYM*)exptr->v.p[0]->v.p[0])->funcparm)
{
exptr = csp->exp;
InitRegs();
sz = csp->size;
ap = gen_expr_external(exptr, FALSE, F_MEM | F_DREG | F_IMMED, sz);
if (csp->reg < 16)
{
if (ap->mode == am_dreg)
peep_tail->oper1->preg = csp->reg;
else
{
if (csp->reg > 3 && chksize(BESZ_WORD, sz))
DIAG("byte sized non-register in analyze");
ap2 = makedreg(csp->reg);
ap2->length = BESZ_DWORD;
if (ap->mode == am_immed || ap->length == BESZ_DWORD || ap
->length == - BESZ_DWORD)
gen_codes(op_mov, BESZ_DWORD, ap2, ap);
else
if (sz < 0)
gen_code(op_movsx, ap2, ap);
else
gen_code(op_movzx, ap2, ap);
}
}
else
if (csp->reg < 32)
{
if (ap->mode == am_dreg)
peep_tail->oper1->preg = csp->reg - 12;
else
{
if (csp->reg - 12 > 3 && chksize(BESZ_WORD, sz))
DIAG("byte sized non-register in analyze");
ap2 = makedreg(csp->reg - 12);
ap2->length = BESZ_DWORD;
if (ap->mode == am_immed || ap->length == BESZ_DWORD || ap
->length == - BESZ_DWORD)
gen_codes(op_mov, BESZ_DWORD, ap2, ap);
else
if (sz < 0)
gen_code(op_movsx, ap2, ap);
else
gen_code(op_movzx, ap2, ap);
}
}
else
{
/* Should never get here */
DIAG("float reg assigned in analyze");
}
if (lvalue(exptr) && ((SYM*)exptr->v.p[0]->v.p[0])->funcparm)
{
((SYM*)exptr->v.p[0]->v.p[0])->mainsym->inreg = TRUE;
((SYM*)exptr->v.p[0]->v.p[0])->mainsym->value.i = - csp
->reg - (csp->size < 0 ? - csp->size: csp->size) *256;
}
}
}
csp = csp->next;
}
gen_label(startlab);
}
LLVMValueRef gen_addr(struct node *ast)
{
return lvalue_to_rvalue(lvalue(ast->one));
}
/*
* This is invoked as a wrapper for 'kbd_putc()'. It writes to the Messages
* scratch buffer, and also to the message line. If the Messages buffer isn't
* visible, it is automatically popped up when a new message line is begun.
* Since it's a scratch buffer, popping it down destroys it.
*/
int
msg_putc(int c)
{
BUFFER *savebp = curbp;
WINDOW *savewp = curwp;
MARK savemk;
int saverow = ttrow;
int savecol = ttcol;
register BUFFER *bp;
register WINDOW *wp;
if ((bp = create_msgs()) == 0)
return TRUE;
savemk = DOT;
beginDisplay();
/*
* Modify the current-buffer state as unobtrusively as possible (i.e.,
* don't modify the buffer order, and don't make the buffer visible if
* it isn't already!). To use the 'bputc()' logic, though, we've got
* to have a window, even if it's not real.
*/
curbp = bp;
if ((wp = bp2any_wp(bp)) == NULL) {
static WINDOW dummy;
wp = &dummy;
wp->w_bufp = bp;
}
curwp = wp;
DOT.l = lback(buf_head(bp));
DOT.o = llength(DOT.l);
/*
* Write into the [Messages]-buffer
*/
#if OPT_TRACE
if (c == '\n') {
static TBUFF *ss;
int len = (DOT.o > 0) ? DOT.o : 1;
if (tb_init(&ss, EOS) != 0
&& tb_bappend(&ss,
(DOT.o > 0) ? lvalue(DOT.l) : "?",
(size_t) len) != 0
&& tb_append(&ss, EOS) != 0) {
TRACE(("msg:%s\n",
visible_buff(tb_values(ss),
(int) tb_length(ss) - 1, TRUE)));
}
}
#endif
if ((c != '\n') || (DOT.o > 0)) {
bputc(c);
b_clr_changed(bp);
}
/* Finally, restore the original current-buffer and write the character
* to the message line.
*/
curbp = savebp;
curwp = savewp;
if (savewp)
DOT = savemk;
movecursor(saverow, savecol);
if (c != '\n') {
if (sgarbf) {
mlsavec(c);
} else {
kbd_putc(c);
}
}
endofDisplay();
return TRUE;
}
LLVMValueRef gen_indir(struct node *ast)
{
return LLVMBuildLoad(builder, lvalue(ast), "");
}
void allocate(int datareg, int addreg, int floatreg, SNODE *block )
/*
* allocate will allocate registers for the expressions that have
* a high enough desirability.
*/
{ CSE *csp;
ENODE *exptr;
unsigned mask, rmask,i,fmask,frmask,size;
AMODE *ap, *ap2;
framedepth = 4+lc_maxauto;
mask = 0;
rmask = 0;
fmask = frmask = 0;
for (i=cf_freedata; i < datareg; i++) {
framedepth+=4;
rmask = rmask | (1 << (15 - i));
mask = mask | (1 << i);
}
for (i=cf_freeaddress+16; i < addreg; i++) {
framedepth+=4;
rmask = rmask | (1 << (23 - i));
mask = mask | (1 << (i-8));
}
while( bsort(&olist) ); /* sort the expression list */
csp = olist;
while( csp != 0 ) {
if (csp->reg == -1 && !(csp->exp->cflags & DF_VOL) && !csp->voidf) {
if( desire(csp) < 3 )
csp->reg = -1;
else {
if (csp->exp->nodetype == en_rcon || csp->exp->nodetype == en_fcon || csp->exp->nodetype == en_lrcon
|| csp->exp->nodetype == en_floatref || csp->exp->nodetype ==en_doubleref
|| csp->exp->nodetype == en_longdoubleref) {
if (floatreg <24 && floatregs)
csp->reg = floatreg++;
}
else if( (datareg < cf_maxdata) && (csp->duses <= csp->uses/4) && dataregs)
csp->reg = (datareg)++;
else if( !(csp->size == 1 || csp->size == -1) && (addreg < cf_maxaddress) &&addrregs)
csp->reg = (addreg)++;
}
}
if( csp->reg != -1 )
{
if (lvalue(csp->exp) && !((SYM *)csp->exp->v.p[0]->v.p[0])->funcparm) {
((SYM *)csp->exp->v.p[0]->v.p[0])->inreg = TRUE;
((SYM *)csp->exp->v.p[0]->v.p[0])->value.i = -csp->reg;
}
if (csp->reg < 16) {
framedepth+=4;
rmask = rmask | (1 << (15 - csp->reg));
mask = mask | (1 << csp->reg);
}
else if (csp->reg < 32) {
framedepth+=4;
rmask = rmask | (1 << (23 - csp->reg));
mask = mask | (1 << (csp->reg-8));
}
else {
framedepth+=12;
frmask = frmask | (1 << (39 - csp->reg));
fmask = fmask | (1 << (csp->reg-32));
}
}
csp = csp->next;
}
allocstack(); /* Allocate stack space for the local vars */
if (currentfunc->tp->lst.head !=0 && currentfunc->tp->lst.head != (SYM *)-1) {
if (prm_phiform || currentfunc->intflag) {
mask |= (1 << (linkreg +8));
rmask |= (1 << (15 - linkreg -8));
framedepth+=4;
}
if (currentfunc->intflag) {
mask |= 0xffff;
rmask |= 0xffff;
framedepth = lc_maxauto;
}
}
if (prm_linkreg && !currentfunc->intflag && (currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1 || lc_maxauto)) {
gen_code(op_link,0,makeareg(linkreg),make_immed(-lc_maxauto));
}
if( mask != 0 )
gen_code(op_movem,4,make_mask(rmask,0,0),push);
save_mask = mask;
if (fmask!=0)
gen_code(op_fmovem,10,make_mask(frmask,0,1),push);
fsave_mask = fmask;
if ((prm_phiform || currentfunc->intflag) && currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *) -1) {
gen_code(op_move,4,makeareg(0), makeareg(linkreg));
}
if ((!prm_linkreg || currentfunc->intflag) && lc_maxauto) {
AMODE *ap = xalloc(sizeof(AMODE));
ap->mode = am_indx;
ap->offset = makenode(en_icon,(char *)-lc_maxauto,0);
ap->preg = 7;
gen_code(op_lea,0,ap,makeareg(7));
}
if (prm_stackcheck) {
AMODE *ap1;
ap = set_symbol("_stackerror",1);
ap1 = set_symbol("_stackbottom",0);
if (prm_rel) {
ap1->mode = am_indx;
ap1->preg = basereg;
}
else {
ap1->mode = am_adirect;
if (prm_smalldata)
ap1->preg = 2;
else
ap1->preg = 4;
}
gen_code(op_cmp,4,ap1,makeareg(7));
gen_code(op_bhi,0,ap,0);
}
}
/* return_hook - called at return statements.
For return *e, return_hook changes the expression to be the equivalent of
the C expression
(_Nub_tos = tos.down, *e)
*/
static void return_hook(void *cl, Symbol cfunc, Tree *e) {
walk(asgn(nub_tos, field(lvalue(idtree(tos)), string("down"))), 0, 0);
}
void ComptaOptions::print_options(const std::string & keyword, const std::string & value)
{
compta_assert(_print_options_map.count(keyword));
switch(_print_options_map.at(keyword))
{
case PRINT::ALL:
{
std::string lvalue(value);
std::transform(lvalue.begin(),lvalue.end(),lvalue.begin(),::tolower);
if(lvalue == NO)
{
_print_forecast = false;
_print_bank = false;
_print_cash = false;
}else if(lvalue == YES)
{
_print_forecast = true;
_print_bank = true;
_print_cash = true;
}else
{
compta_option_error("Unrecognized value for option --print: " + value + "\nPlease use \"" + YES + "\" or \"" + NO + "\"");
}
break;
}
case PRINT::FORECAST:
{
_print_forecast = true;
break;
}
case PRINT::BANK:
{
_print_bank = true;
break;
}
case PRINT::CASH:
{
_print_cash = true;
break;
}
case PRINT::BANK_HISTORY:
{
if(SplitString(value,",",_print_bank_history,false) == 0)_print_bank_history.push_back(value);
shave_string(_print_bank_history);
break;
}
case PRINT::CASH_HISTORY:
{
if(SplitString(value,",",_print_cash_history,false) == 0)_print_cash_history.push_back(value);
shave_string(_print_cash_history);
break;
}
case PRINT::ALL_DATA:
{
_print_all_data = true;
break;
}
case PRINT::FROM:
{
_from_stdout.set_date(value);
break;
}
case PRINT::TO:
{
_to_stdout.set_date(value);
break;
}
default: //WTF???
{
compta_error();
}
}
}
/*
* Bulk transfer routine to remote host --
* used by sendfile() and cu_put()
*/
static void
transmit(FILE *fp, char *eofchars, char *command)
{
char *pc, lastc;
int c, ccount, lcount;
time_t start_t, stop_t;
sig_t f;
kill(tipout_pid, SIGIOT); /* put TIPOUT into a wait state */
stop = 0;
f = signal(SIGINT, stopsnd);
tcsetattr(0, TCSAFLUSH, &defchars);
read(repdes[0], (char *)&ccc, 1);
if (command != NULL) {
for (pc = command; *pc; pc++)
send(*pc);
if (boolean(value(ECHOCHECK)))
read(FD, (char *)&c, 1); /* trailing \n */
else {
tcdrain(FD);
sleep(5); /* wait for remote stty to take effect */
}
}
lcount = 0;
lastc = '\0';
start_t = time(0);
while (1) {
ccount = 0;
do {
c = getc(fp);
if (stop)
goto out;
if (c == EOF)
goto out;
if (c == 0177 && !boolean(value(RAWFTP)))
continue;
lastc = c;
if (c < 040) {
if (c == '\n') {
if (!boolean(value(RAWFTP)))
c = '\r';
} else if (c == '\t') {
if (!boolean(value(RAWFTP))) {
if (boolean(value(TABEXPAND))) {
send(' ');
while ((++ccount % 8) != 0)
send(' ');
continue;
}
}
} else
if (!boolean(value(RAWFTP)))
continue;
}
send(c);
} while (c != '\r' && !boolean(value(RAWFTP)));
if (boolean(value(VERBOSE)))
printf("\r%d", ++lcount);
if (boolean(value(ECHOCHECK))) {
timedout = 0;
alarm((unsigned int)lvalue(ETIMEOUT));
do { /* wait for prompt */
read(FD, (char *)&c, 1);
if (timedout || stop) {
if (timedout)
printf("\r\ntimed out at eol\r\n");
alarm(0);
goto out;
}
} while ((c&STRIP_PAR) != character(value(PROMPT)));
alarm(0);
}
}
out:
if (lastc != '\n' && !boolean(value(RAWFTP)))
send('\r');
if (eofchars) {
for (pc = eofchars; *pc; pc++)
send(*pc);
}
stop_t = time(0);
fclose(fp);
signal(SIGINT, f);
if (boolean(value(VERBOSE))) {
if (boolean(value(RAWFTP)))
prtime(" chars transferred in ", stop_t-start_t);
else
prtime(" lines transferred in ", stop_t-start_t);
}
write(fildes[1], (char *)&ccc, 1);
tcsetattr(0, TCSAFLUSH, &term);
}
