void ir_ternary(nodeType* n)
{
nodeType* expr = get_operand(n,0);
nodeType* stmt1 = get_operand(n,1);
nodeType* stmt2 = get_operand(n,2);
set_T(expr,newlabel());
set_F(expr,newlabel());
memset(stmt1->opr.next,0,16);
memset(stmt2->opr.next,0,16);
memset(n->opr.next,0,16);
strcpy(stmt1->opr.next,n->opr.next);
strcpy(stmt2->opr.next,n->opr.next);
strcpy(n->opr.next,newlabel());
seen_bool_flow = 1;
generate(expr);
seen_bool_flow = 0;
debugger("%s:\n",get_T(expr));
fprintf(output,"%s:\n",get_T(expr));
prepost_put = 1;
generate(stmt1);
prepost_put = 0;
debugger("br.s %s\n ",n->opr.next);
fprintf(output,"br.s %s\n",n->opr.next);
debugger("%s:\n",get_F(expr));
fprintf(output,"%s:\n",get_F(expr));
prepost_put = 1;
generate(stmt2);
prepost_put = 0;
debugger("%s:\n",n->opr.next);
fprintf(output,"%s:\n",n->opr.next);
}
void ir_for(nodeType* n)
{
nodeType* initialize = get_operand(n,0);
nodeType* expr = get_operand(n,1);
nodeType* increament = get_operand(n,2);
nodeType* stmt = get_operand(n,3);
char initializenext[16], begin[16];
memset(initializenext,0,16);
memset(begin,0,16);
strcat(initializenext,newlabel());
strcat(begin,newlabel());
set_T(expr,begin);
set_F(expr,n->opr.next);
generate(initialize); //generate code for initialization expression
//##for break statement##
char initial_break_label[16];
memset(initial_break_label,0,16);
strcpy(initial_break_label,break_label);
memset(break_label,0,16);
strcpy(break_label,newlabel());
//#####for continue statement############
char initial_continue_label[16];
memset(initial_continue_label,0,16);
strcpy(initial_continue_label,continue_label);
memset(continue_label,0,16);
strcpy(continue_label,newlabel());
//#######################################
loop_flag = loop_flag + 1;
debugger("br %s\n",initializenext);
fprintf(output,"br %s\n",initializenext);
debugger("%s: \n",begin);
fprintf(output,"%s: ",begin);
generate(stmt);
prepost_put = 0;
debugger("%s:\n",continue_label);
fprintf(output,"%s:\n",continue_label);
generate(increament);
debugger("%s: ",initializenext);
fprintf(output,"%s: ",initializenext);
seen_bool_flow = 1;
generate(expr);
seen_bool_flow = 0;
debugger("%s: \n",break_label);
fprintf(output,"%s: \n",break_label);
//for break statement
loop_flag = loop_flag - 1;
memset(break_label,0,16);
strcpy(break_label,initial_break_label);
memset(continue_label,0,16);
strcpy(continue_label,initial_continue_label);
}
void
puthead(char *s)
{
struct interpass_prolog *ipp = ckalloc(sizeof(struct interpass_prolog));
int olbl, lbl1, lbl2;
unsigned int i;
if (s == NULL)
return;
if (inproc)
fatal1("puthead %s in procedure", s);
inproc = s;
olbl = lastlabno;
lbl1 = newlabel();
lbl2 = newlabel();
for (i = 0; i < NIPPREGS; i++)
ipp->ipp_regs[i] = 0; /* no regs used yet */
ipp->ipp_autos = 0; /* no autos used yet */
ipp->ipp_name = copys(s); /* function name */
ipp->ipp_type = INT; /* type not known yet? */
ipp->ipp_vis = 1; /* always visible */
ipp->ip_tmpnum = 0; /* no temp nodes used in F77 yet */
ipp->ip_lblnum = olbl; /* # used labels so far */
ipp->ipp_ip.ip_lbl = lbl1; /* first label, for optim */
ipp->ipp_ip.type = IP_PROLOG;
pass2_compile((struct interpass *)ipp);
}
void ir_bool_flow(nodeType* n)
{
nodeType* B1 = get_operand(n,0);
nodeType* B2 = get_operand(n,1);
debugger("n true label:%s\n",get_T(n));
debugger("n false label:%s\n",get_F(n));
switch(n->opr.oper)
{
case BOOL_OR:
debugger("MATCHED BOOL_OR in ir_bool_flow\n");
set_T(B1,n->opr.T);
set_F(B1,newlabel());
set_T(B2,n->opr.T);
set_F(B2,n->opr.F);
generate(B1);
debugger("%s:",get_F(B1));
fprintf(output,"%s:",get_F(B1));
debugger("seen_bool_flow : %d\n",seen_bool_flow);
generate(B2);
break;
case BOOL_EQ:
//the rule is to load value of B1 and B2 on stack then use beq to jump accordingly so we have to switch of seen_bool_flow flag and restart later.
seen_bool_flow = 0;
generate(B1);
generate(B2);
seen_bool_flow = 1;
debugger("MATCHED BOOL_EQ in ir_relop_flow\n");
debugger("beq %s\n",get_T(n));
fprintf(output,"beq %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case NEQ:
debugger("NOT EQUAL TO\n");
//the rule is to load value of B1 and B2 on stack then use bne.un to jump accordingly so we have to switch of seen_bool_flow flag and restart later.
seen_bool_flow = 0;
generate(B1);
generate(B2);
seen_bool_flow = 1;
debugger("MATCHED NEQ in ir_relop_flow\n");
debugger("bne.un %s\n",get_T(n));
fprintf(output,"bne.un %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case BOOL_AND:
set_T(B1,newlabel());
set_F(B1, get_F(n));
set_T(B2, get_T(n));
set_F(B2, get_F(n));
generate(B1);
debugger("%s:",get_T(B1));
fprintf(output,"%s:",get_T(B1));
generate(B2);
break;
default: debugger("Bool DEFAULT\n");
}
}
char *askUserPass(const char *title)
{
static window win = NULL;
dialog_data *d;
window prev = current_window;
if (! win) {
int tw, bw, h, middle;
tw = strwidth(SystemFont, G_("Cancel")) * 8;
h = getheight(SystemFont);
if (tw < 150) tw = 150;
win = newwindow(title, rect(0, 0, tw+30, h*9+12),
Titlebar | Centered | Modal);
setbackground(win, dialog_bg());
add_data(win);
d = data(win);
d->question = newlabel(G_("User"), rect(10, h, tw+4, h*2+2), AlignLeft);
bw = strwidth(SystemFont, G_("Password"));
d->text = newfield("", rect(20+bw, h, tw-6-bw, h*3/2));
newlabel(_("Password"), rect(10, h*4, tw+4, h*2+2), AlignLeft);
d->pass = newpassword("", rect(20+bw, h*4, tw-6-bw, h*3/2));
middle = (tw+30)/2;
bw = strwidth(SystemFont, G_("Cancel")) * 3/2;
d->yes = newbutton(G_("OK"),
rect(middle-bw-10, h*7, bw, h+10), hit_button);
setvalue(d->yes, YES);
d->cancel = newbutton(G_("Cancel"),
rect(middle+10, h*7, bw, h+10), hit_button);
setvalue(d->cancel, CANCEL);
setkeydown(win, hit_key);
} else {
d = data(win);
settext(d->text, "");
settext(d->pass, "");
}
if (TopmostDialogs & MB_TOPMOST)
BringToTop(win, 1);
handle_message_dialog(win);
current_window = prev;
{
char *user, *pass;
static char buf[1000];
if (d->hit < YES) /* cancelled */ return "";
if (d->text) user = new_string(GA_gettext(d->text));
else return "";
if (d->pass) pass = new_string(GA_gettext(d->pass));
else return "";
snprintf(buf, 1000, "%s:%s", user, pass);
return buf;
}
return ""; /* -Wall */
}
void ir_bool(nodeType* n)
{
debugger("in ir_bool\n");
nodeType* B1 = get_operand(n,0);
nodeType* B2 = get_operand(n,1);
char* label1;
char* label2;
switch(n->opr.oper)
{
case NEQ:
generate(B1);
generate(B2);
debugger("ceq\n");
fprintf(output,"ceq\n");
debugger("ldc.i4.0\n");
fprintf(output,"ldc.i4.0\n");
debugger("ceq\n");
fprintf(output,"ceq\n");
break;
case BOOL_EQ:
generate(B1);
generate(B2);
debugger("ceq\n");
fprintf(output,"ceq\n");
break;
case BOOL_OR:
generate(B1);
label1 = strdup(newlabel());
debugger("brtrue %s\n",label1);
fprintf(output,"brtrue %s\n",label1);
generate(B2);
label2 = strdup(newlabel());
debugger("br.s %s\n",label2);
fprintf(output,"br.s %s\n",label2);
debugger("%s: ldc.i4.1 \n",label1);
fprintf(output,"%s: ldc.i4.1 \n",label1);
debugger("%s: ",label2);
fprintf(output,"%s: ",label2);
break;
case BOOL_AND:
generate(B1);
label1 = strdup(newlabel());
debugger("brfalse %s\n",label1);
fprintf(output,"brfalse %s\n",label1);
generate(B2);
label2 = strdup(newlabel());
debugger("br.s %s\n",label2);
fprintf(output,"br.s %s\n",label2);
debugger("%s: ldc.i4.0\n",label1);
fprintf(output,"%s: ldc.i4.0\n",label1);
debugger("%s: ",label2);
fprintf(output,"%s: ",label2);
break;
default: debugger("Bool DEFAULT\n");
}
}
void IfElse::gen(label before, label after)
{
label iftrue = newlabel();
label iffalse = newlabel();
e->jumping(0,iffalse);
emitlabel(iftrue);
stmt1->gen(iftrue,after);
emit("goto L"+after);
emitlabel(iffalse);
stmt2->gen(iffalse,after);
}
void ir_while(nodeType* n)
{
nodeType* expr = get_operand(n,0);
nodeType* stmt = get_operand(n,1);
char begin[16];
memset(begin,0,16);
strcat(begin,newlabel());
set_T(expr,newlabel());
set_F(expr,n->opr.next);
memset(stmt->opr.next,0,16);
strcpy(stmt->opr.next,begin);
debugger("%s:\n",begin);
fprintf(output,"%s:\n",begin);
seen_bool_flow = 1;prepost_put = 1;
generate(expr);
seen_bool_flow = 0;prepost_put = 0;
debugger("%s:\n",get_T(expr));
fprintf(output,"%s:\n",get_T(expr));
//##for break statement##
char initial_break_label[16];
memset(initial_break_label,0,16);
strcat(initial_break_label,break_label);
memset(break_label,0,16);
loop_flag = loop_flag + 1;
strcat(break_label,n->opr.next);
//#####for continue statement############
char initial_continue_label[16];
memset(initial_continue_label,0,16);
strcpy(initial_continue_label,continue_label);
memset(continue_label,0,16);
strcpy(continue_label,begin);
debugger("CONTINUE LABEL: %s\n",continue_label);
//#######################################
generate(stmt);
debugger("br.s %s\n ",begin);
fprintf(output,"br.s %s\n",begin);
//for break statement
loop_flag = loop_flag - 1;
memset(break_label,0,16);
strcat(break_label,initial_break_label);
memset(continue_label,0,16);
strcpy(continue_label,initial_continue_label);
}
void DoWhile::gen(label before, label after)
{
label test = newlabel();
s->gen(before,test);
emitlabel(test);
e->jumping(before,0);
}
void If::gen(label before, label after)
{
label iftrue = newlabel();
e->jumping(0,after);
emitlabel(iftrue);
s->gen(iftrue,after);
}
/*
integer width
integer height
integer size
uinteger color
string l/r/c
ret: userdata
*/
static int
lnewlabel(lua_State *L) {
struct pack_label label;
label.width = (int)luaL_checkinteger(L,1);
label.height = (int)luaL_checkinteger(L,2);
label.size = (int)luaL_checkinteger(L,3);
label.color = (uint32_t)luaL_optunsigned(L,4,0xffffffff);
const char * align = lua_tostring(L,5);
if (align == NULL) {
label.align = LABEL_ALIGN_LEFT;
} else {
switch(align[0]) {
case 'l':
case 'L':
label.align = LABEL_ALIGN_LEFT;
break;
case 'r':
case 'R':
label.align = LABEL_ALIGN_RIGHT;
break;
case 'c':
case 'C':
label.align = LABEL_ALIGN_CENTER;
break;
default:
return luaL_error(L, "Align must be left/right/center");
}
}
newlabel(L, &label);
return 1;
}
void ir_if(nodeType* n)
{
nodeType* expr = get_operand(n,0);
nodeType* stmt = get_operand(n,1);
set_T(expr,newlabel());
set_F(expr,n->opr.next);
memset(stmt->opr.next,0,16);
strcat(stmt->opr.next,n->opr.next);
debugger("expr true label:%s\n",get_T(expr));
debugger("expr false label:%s\n",get_F(expr));
seen_bool_flow = 1;prepost_put = 1;
generate(expr);
seen_bool_flow = 0;prepost_put = 0;
debugger("%s:\n",get_T(expr));
fprintf(output,"%s:\n",get_T(expr));
generate(stmt);
return;
}
void ir_compound_stmt(nodeType* n)
{
debugger("{\n");
fprintf(output,"{\n");
if(main_found==1) // main flag set so this is entrypoint
{
debugger(" .entrypoint\n");
fprintf(output," .entrypoint\n");
main_found=0;
}
if(in_func==1) // in every function need to set max stack
{
debugger(".maxstack %d\n",MAXSTACK_SIZE); // GIGLAMESH use a define here
fprintf(output,".maxstack %d\n",MAXSTACK_SIZE);
in_func=0;
}
nodeType* stmtlist = get_operand(n,0);
memset(stmtlist->opr.next,0,16);
strcat(stmtlist->opr.next,newlabel()); // attach a new label to stmt next
generate(stmtlist);
debugger("%s:\n",stmtlist->opr.next);
fprintf(output,"%s:\n",stmtlist->opr.next);
debugger("}\n");
fprintf(output,"}\n");
}
mklabel(ftnint l)
#endif
{
register struct Labelblock *lp;
if(l <= 0)
return(NULL);
for(lp = labeltab ; lp < highlabtab ; ++lp)
if(lp->stateno == l)
return(lp);
if(++highlabtab > labtabend)
many("statement labels", 's', maxstno);
lp->stateno = l;
lp->labelno = (int)newlabel();
lp->blklevel = 0;
lp->labused = NO;
lp->fmtlabused = NO;
lp->labdefined = NO;
lp->labinacc = NO;
lp->labtype = LABUNKNOWN;
lp->fmtstring = 0;
return(lp);
}
static void
cond(Node *n)
{
char *lfalse, *lend;
if(!isitype(n->type) && !isptr(n->type))
panic("unimplemented emit cond");
expr(n->Cond.cond);
lfalse = newlabel();
lend = newlabel();
outi("test %%rax, %%rax\n");
outi("jz %s\n", lfalse);
expr(n->Cond.iftrue);
outi("jmp %s\n", lend);
out("%s:\n", lfalse);
expr(n->Cond.iffalse);
out("%s:\n", lend);
}
Expr * Logical::gen()
{
int f = newlabel();
int a = newlabel();
Temp * temp = new Temp(this->type);
this->jumping(0,f);
//emit(temp->toString() + " = true");
emit("(=, true, " + temp->toString() + ")");
log_buffer << a;
emit("goto L" + log_buffer.str());
log_buffer.str("");
emitlabel(f);
//emit(temp->toString() + " = false");
emit("(=, false, " + temp->toString() + ")");
emitlabel(a);
return temp;
}
static void
str(Node *n)
{
char *l;
l = newlabel();
penddata(l, n->type, n, 0);
outi("leaq %s(%%rip), %%rax\n", l);
outi("movq (%%rax), %%rax\n", l);
}
static void create_dialog()
{
setcursor(ArrowCursor); /* not `busy' cursor */
win = newwindow("t-test entry", rect(0, 0, 200, 200),
Titlebar | Centered | Modal);
setbackground(win, dialog_bg());
setkeydown(win, hit_key);
bApply = newbutton("Apply", rect(20, 160, 50, 25), apply);
bCancel = newbutton("Cancel", rect(120, 160, 50, 25), NULL);
l_var1 = newlabel("x", rect(10, 10, 30, 20), AlignLeft);
var1 = newfield("", rect(40, 10, 130, 20));
l_var2 = newlabel("y", rect(10, 40, 30, 20), AlignLeft);
var2 = newfield("", rect(40, 40, 130, 20));
paired = newcheckbox("paired", rect(10, 70, 80, 20), NULL);
varequal = newcheckbox("equal var", rect(110, 70, 80, 20), NULL);
alt = newdroplist(alts , rect(30, 90, 120, 20), NULL);
setlistitem(alt, 0);
l_lvl = newlabel("confidence level", rect(20, 120, 90, 20), AlignLeft);
lvl = newfield("0.95", rect(120, 120, 40, 20));
}
muiObject *muiNewBoldLabel(int xmin, int ymin, char *label)
{
muiObject *newlbl = newmuiobj();
newlbl->type = MUI_BOLDLABEL;
newlbl->xmin = xmin;
newlbl->ymin = ymin;
/* XXX maximums */
newlbl->object = (void *)newlabel(label);
newlbl->handler = nullhandler;
return newlbl;
}
void Seq::gen(label begin , label after){
if(s1 == Stmt::Null)
s2->gen(begin,after);
else if(s2 == Stmt::Null)
s1->gen(begin,after);
else if(s1 != Stmt::Null && s2 != Stmt::Null){
label l = newlabel();
s1->gen(begin,l);
emitlabel(l);
s2->gen(l,after);
}
}
void ir_default_stmt(nodeType* n)
{
nodeType* stmt = get_operand(n,0);
char mylabel[16];
memset(mylabel,0,16);
strcat(mylabel,newlabel());
debugger("%s: ",mylabel);
fprintf(output,"%s: ",mylabel);
generate(stmt);
nodeType* const_exp = empty(EMPTY);
insert_queue(const_exp,mylabel);
}
static void
shortcircuit(Node *n)
{
char *t, *f, *e;
t = newlabel();
f = newlabel();
e = newlabel();
expr(n->Binop.l);
if(n->Binop.op == TOKLAND) {
outi("testq %%rax, %%rax\n");
outi("jz %s\n", f);
} else if(n->Binop.op == TOKLOR) {
outi("testq %%rax, %%rax\n");
outi("jnz %s\n", t);
} else {
panic("internal error");
}
expr(n->Binop.r);
if(n->Binop.op == TOKLAND) {
outi("testq %%rax, %%rax\n");
outi("jz %s\n", f);
outi("jmp %s\n", t);
} else if(n->Binop.op == TOKLOR) {
outi("testq %%rax, %%rax\n");
outi("jnz %s\n", t);
outi("jmp %s\n", f);
} else {
panic("internal error");
}
out("%s:\n", t);
outi("mov $1, %%rax\n");
outi("jmp %s\n", e);
out("%s:\n", f);
outi("xor %%rax, %%rax\n");
outi("jmp %s\n", e);
out("%s:\n", e);
}
static void
data(Data *d)
{
InitMember *initmemb;
int i, offset;
char *l;
if(!d->init) {
out(".comm %s, %d, %d\n", d->label, d->type->size, d->type->align);
return;
}
if(d->isglobal)
out(".globl %s\n", d->label);
out("%s:\n", d->label);
if(ischararray(d->type))
if(d->init->t == NSTR) {
out(".string %s\n", d->init->Str.v);
return;
}
if(ischarptr(d->type))
if(d->init->t == NSTR) {
l = newlabel();
out(".quad %s\n", l);
out("%s:\n", l);
out(".string %s\n", d->init->Str.v);
return;
}
if(isitype(d->type) || isptr(d->type)) {
itypedata(d->init);
return;
}
if(isarray(d->type) || isstruct(d->type)) {
if(d->init->t != NINIT)
errorposf(&d->init->pos, "array/struct expects a '{' style initializer");
offset = 0;
for(i = 0; i < d->init->Init.inits->len ; i++) {
initmemb = vecget(d->init->Init.inits, i);
if(initmemb->offset != offset)
out(".fill %d, 1, 0\n", initmemb->offset - offset);
itypedata(initmemb->n);
offset = initmemb->offset + initmemb->n->type->size;
}
if(offset < d->type->size)
out(".fill %d, 1, 0\n", d->type->size - offset);
return;
}
panic("internal error");
}
/* winProgressBar(width, title, label, min, max, initial) */
SEXP winProgressBar(SEXP call, SEXP op, SEXP args, SEXP env)
{
SEXP tmp, ptr;
int width, iv;
double d;
const char *title, *label;
winprogressbar *pbar;
Rboolean haveLabel;
args = CDR(args);
pbar = Calloc(1, winprogressbar);
width = asInteger(CAR(args)); args = CDR(args);
if(width == NA_INTEGER || width < 0) width = 200;
tmp = CAR(args); args = CDR(args);
if(!isString(tmp) || length(tmp) < 1 || STRING_ELT(tmp, 0) == NA_STRING)
errorcall(call, "invalid '%s' argument", "title");
title = translateChar(STRING_ELT(tmp, 0));
tmp = CAR(args); args = CDR(args);
if(!isString(tmp) || length(tmp) < 1 || STRING_ELT(tmp, 0) == NA_STRING)
errorcall(call, "invalid '%s' argument", "Label");
label = translateChar(STRING_ELT(tmp, 0));
haveLabel = strlen(label) > 0;
d = asReal(CAR(args)); args = CDR(args);
if (!R_FINITE(d)) errorcall(call, "invalid '%s' argument", "min");
pbar->min = d;
d = asReal(CAR(args)); args = CDR(args);
if (!R_FINITE(d)) errorcall(call, "invalid '%s' argument", "max");
pbar->max = d;
d = asReal(CAR(args)); args = CDR(args);
if (!R_FINITE(d)) errorcall(call, "invalid '%s' argument", "initial");
pbar->val = d;
pbar->width = width;
pbar->wprog = newwindow(title, rect(0, 0, width+40, haveLabel ? 100: 80),
Titlebar | Centered);
setbackground(pbar->wprog, dialog_bg());
if(haveLabel)
pbar->lab = newlabel(label, rect(10, 15, width+20, 25), AlignCenter);
pbar->pb = newprogressbar(rect(20, haveLabel ? 50 : 30, width, 20),
0, width, 1, 1);
iv = pbar->width * (pbar->val - pbar->min)/(pbar->max - pbar->min);
setprogressbar(pbar->pb, iv);
show(pbar->wprog);
ptr = R_MakeExternalPtr(pbar, install("winProgressBar"), R_NilValue);
R_RegisterCFinalizerEx(ptr, pbarFinalizer, TRUE);
return ptr;
}
static void
eif(Node *n)
{
char *end;
end = newlabel();
expr(n->If.expr);
outi("test %%rax, %%rax\n");
outi("jz %s\n", n->If.lelse);
stmt(n->If.iftrue);
outi("jmp %s\n", end);
out("%s:\n", n->If.lelse);
if(n->If.iffalse)
stmt(n->If.iffalse);
out("%s:\n", end);
}
void ir_stmtlist(nodeType* n)
{
nodeType* Stmtlist = get_operand(n,0);
nodeType* Stmt = get_operand(n,1);
memset(Stmtlist->opr.next,0,16);
strcat(Stmtlist->opr.next,newlabel());
debugger("Stmtlist next:%s \n",Stmtlist->opr.next);
debugger("Stmtlist type:%d \n",Stmtlist->type);
debugger("Stmtlist nops:%d \n",Stmtlist->opr.nops);
generate(Stmtlist);
memset(Stmt->opr.next,0,16);
strcat(Stmt->opr.next,n->opr.next);
debugger("%s: \n",Stmtlist->opr.next);
fprintf(output,"%s: \n",Stmtlist->opr.next);
generate(Stmt);
}
static void
dotext(double x, double y, obj *p) /* print text strings of p in proper vertical spacing */
{
double h, v, w, dely, *bnd;
int i, j, m, n, t;
int nt2 = p->o_nt2;
bnd = text_bounds(p);
v = bnd[3]; /* includes ABOVE/BELOW attributes */
j = text[p->o_nt1].t_line;
new_color(p->o_text);
for (h = w = 0, i = p->o_nt1; i < nt2; h = w = 0) {
/* calculate position of baseline for this line--assumed to be
down 3/4 of maximum character height from top of line */
for (m = 0, n = i; n < nt2 && text[n].t_line == j; n++) {
w += text[n].t_width*72/pgscale;
if (abs(text[n].t_size) > m)
m = abs(text[n].t_size);
}
dely = (double) m / pgscale; /* max size, in inches */
t = text[i].t_type;
#if 0
/* Note the adjustments for ABOVE and BELOW are permanent--affect
all subsequent strings in this object */
if (t & ABOVE)
v += dely / 2;
else if (t & BELOW)
v -= dely / 2;
#endif
dely *= .75;
if (t & RJUST)
h = w;
else if (t & CENTER)
h = w/2;
newlabel(t, text[i].t_val, abs(text[i].t_font), x-h, y + v - dely,
text[i].t_size / pgscale,
text[i].t_width * 72 / pgscale);
v -= (double) abs(text[i].t_space) / pgscale;
while (++i < n)
addlabel(text[i].t_type, text[i].t_val,
text[i].t_font, text[i].t_size / pgscale,
text[i].t_width * 72 / pgscale);
j = text[i].t_line; /* line numbers not necessarily consecutive! */
}
}
static window init_askstr_dialog(const char *title, const char *question,
const char *default_str)
{
window win;
dialog_data *d;
int tw, bw, h, middle;
if (! question)
question= "";
if (! default_str)
default_str = "";
tw = strwidth(SystemFont, G_("Cancel")) * 8;
h = getheight(SystemFont);
if (tw < 150) tw = 150;
win = newwindow(title, rect(0,0,tw+30,h*9+12),
Titlebar | Centered | Modal);
setbackground(win, dialog_bg());
add_data(win);
d = data(win);
d->question = newlabel(question, rect(10,h,tw+4,h*2+2),
AlignLeft);
if (title == PASSWORD_TITLE)
d->text = newpassword(default_str, rect(10,h*4,tw+4,h*3/2));
else
d->text = newfield(default_str, rect(10,h*4,tw+4,h*3/2));
middle = (tw+30)/2;
bw = strwidth(SystemFont, G_("Cancel")) * 3/2;
d->yes = newbutton(G_("OK"),
rect(middle-bw-10, h*7, bw, h+10), hit_button);
setvalue(d->yes, YES);
d->cancel = newbutton(G_("Cancel"),
rect(middle+10, h*7, bw, h+10), hit_button);
setvalue(d->cancel, CANCEL);
setkeydown(win, hit_key);
return win;
}
void ir_switch(nodeType* n)
{
nodeType* expr = get_operand(n,0);
nodeType* case_stmt_list = get_operand(n,1);
generate(expr);//after this the value of expr will be on stack
int default_present=0;
char test_label[16];
char old_break_label[16];
char end_label[16];
memset(test_label,0,16);
strcat(test_label,newlabel());
//at the starting jump to test the cases.
debugger("br %s\n",test_label);
fprintf(output,"br %s\n",test_label);
switch_flag++;
//label that will appear at the end of switch
memset(end_label,0,16);
strcat(end_label,newlabel());
//maybe someone is already using the break label so save it so as to restore it later
memset(old_break_label,0,16);
strcat(old_break_label,break_label);
//set the label to be used for break statements in switch
memset(break_label,0,16);
strcat(break_label,end_label);
generate(case_stmt_list);
//after default jump to end of switch statement
debugger("br %s\n",end_label);
fprintf(output,"br %s\n",end_label);
//jump here to test the conditions
debugger("%s:\n",test_label);
fprintf(output,"%s:\n",test_label);
int count = 0;
nodeType* const_exp;
char* label;
queue_length = queue_length -1;
debugger("QUEUE LENGTH:%d\n",queue_length);
while(count <= queue_length) //since at the end queue_length is one more than the actual queue length
{
const_exp = expr_queue[count];
if(const_exp->type == typeOpr )
{
//the below if else handles default statement
if(const_exp->opr.oper == EMPTY)
{
default_present = 1;
debugger("br %s\n",label_queue[count]);
fprintf(output,"br %s\n",label_queue[count]);
}
else
{
generate(const_exp);
debugger("beq %s\n",label_queue[count]);
fprintf(output,"beq %s\n",label_queue[count]);
}
}
else
{
generate(const_exp);
debugger("beq %s\n",label_queue[count]);
fprintf(output,"beq %s\n",label_queue[count]);
}
if(count <= queue_length-1- default_present) //do not do it after the last statement //recheck this condition
{
//debugger("KJKJOK\n");
generate(expr); //basically this will load the value of x in switch(x) on the stack
}
count++;
}
queue_length = 0;
debugger("%s:\n",end_label);
fprintf(output,"%s:\n",end_label);
switch_flag--;
memset(break_label,0,16);
strcat(break_label,old_break_label);
}
putconst(register Constp p)
#endif
{
register Addrp q;
struct Literal *litp, *lastlit;
int k, len, type;
int litflavor;
double cd[2];
ftnint nblanks;
char *strp;
char cdsbuf0[64], cdsbuf1[64], *ds[2];
if (p->tag != TCONST)
badtag("putconst", p->tag);
q = ALLOC(Addrblock);
q->tag = TADDR;
type = p->vtype;
q->vtype = ( type==TYADDR ? tyint : type );
q->vleng = (expptr) cpexpr(p->vleng);
q->vstg = STGCONST;
/* Create the new label for the constant. This is wasteful of labels
because when the constant value already exists in the literal pool,
this label gets thrown away and is never reclaimed. It might be
cleaner to move this down past the first switch() statement below */
q->memno = newlabel();
q->memoffset = ICON(0);
q -> uname_tag = UNAM_CONST;
/* Copy the constant info into the Addrblock; do this by copying the
largest storage elts */
q -> user.Const = p -> Const;
q->user.kludge.vstg1 = p->vstg; /* distinguish string from binary fp */
/* check for value in literal pool, and update pool if necessary */
k = 1;
switch(type)
{
case TYCHAR:
if (halign) {
strp = p->Const.ccp;
nblanks = p->Const.ccp1.blanks;
len = p->vleng->constblock.Const.ci;
litflavor = LIT_CHAR;
goto loop;
}
else
q->memno = BAD_MEMNO;
break;
case TYCOMPLEX:
case TYDCOMPLEX:
k = 2;
if (p->vstg)
cd[1] = atof(ds[1] = p->Const.cds[1]);
else
ds[1] = cds(dtos(cd[1] = p->Const.cd[1]), cdsbuf1);
case TYREAL:
case TYDREAL:
litflavor = LIT_FLOAT;
if (p->vstg)
cd[0] = atof(ds[0] = p->Const.cds[0]);
else
ds[0] = cds(dtos(cd[0] = p->Const.cd[0]), cdsbuf0);
goto loop;
case TYLOGICAL1:
case TYLOGICAL2:
case TYLOGICAL:
type = tylogical;
goto lit_int_flavor;
case TYLONG:
type = tyint;
case TYSHORT:
case TYINT1:
#ifdef TYQUAD
case TYQUAD:
#endif
lit_int_flavor:
litflavor = LIT_INT;
/* Scan the literal pool for this constant value. If this same constant
has been assigned before, use the same label. Note that this routine
does NOT consider two differently-typed constants with the same bit
pattern to be the same constant */
loop:
lastlit = litpool + nliterals;
for(litp = litpool ; litp<lastlit ; ++litp)
/* Remove this type checking to ensure that all bit patterns are reused */
if(type == litp->littype) switch(litflavor)
{
case LIT_CHAR:
if (len == (int)litp->litval.litival2[0]
&& nblanks == litp->litval.litival2[1]
&& !memcmp(strp, litp->cds[0], len)) {
q->memno = litp->litnum;
frexpr((expptr)p);
q->user.Const.ccp1.ccp0 = litp->cds[0];
return(q);
}
break;
case LIT_FLOAT:
if(cd[0] == litp->litval.litdval[0]
&& !strcmp(ds[0], litp->cds[0])
&& (k == 1 ||
cd[1] == litp->litval.litdval[1]
&& !strcmp(ds[1], litp->cds[1]))) {
ret:
q->memno = litp->litnum;
frexpr((expptr)p);
return(q);
}
break;
case LIT_INT:
if(p->Const.ci == litp->litval.litival)
goto ret;
break;
}
/* If there's room in the literal pool, add this new value to the pool */
if(nliterals < maxliterals)
{
++nliterals;
/* litp now points to the next free elt */
litp->littype = type;
litp->litnum = q->memno;
switch(litflavor)
{
case LIT_CHAR:
litp->litval.litival2[0] = len;
litp->litval.litival2[1] = nblanks;
q->user.Const.ccp = litp->cds[0] =
memcpy(gmem(len,0), strp, len);
break;
case LIT_FLOAT:
litp->litval.litdval[0] = cd[0];
litp->cds[0] = copys(ds[0]);
if (k == 2) {
litp->litval.litdval[1] = cd[1];
litp->cds[1] = copys(ds[1]);
}
break;
case LIT_INT:
litp->litval.litival = p->Const.ci;
break;
} /* switch (litflavor) */
}
else
many("literal constants", 'L', maxliterals);
break;
case TYADDR:
break;
default:
badtype ("putconst", p -> vtype);
break;
} /* switch */
if (type != TYCHAR || halign)
frexpr((expptr)p);
return( q );
}
