void SymIdFunc::execute() {
// return id of each symbol in the arguments
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
int symbol_ids[numargs];
for (int i=0; i<numargs; i++) {
ComValue& val = stack_arg(i, true);
if (val.is_type(AttributeValue::CommandType))
symbol_ids[i] = val.command_symid();
else if (val.is_type(AttributeValue::StringType))
symbol_ids[i] = val.string_val();
else if (val.is_type(AttributeValue::SymbolType))
symbol_ids[i] = val.symbol_val();
else
symbol_ids[i] = -1;
}
reset_stack();
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++)
avl->Append(new AttributeValue(symbol_ids[i], AttributeValue::IntType));
push_stack(retval);
} else {
ComValue retval (symbol_ids[0], AttributeValue::IntType);
push_stack(retval);
}
}
void TransformerFunc::execute() {
ComValue objv(stack_arg(0));
ComValue transv(stack_arg(0));
reset_stack();
if (objv.object_compview()) {
ComponentView* compview = (ComponentView*)objv.obj_val();
if (compview && compview->GetSubject()) {
OverlayComp* comp = (OverlayComp*)compview->GetSubject();
Graphic* gr = comp->GetGraphic();
if (gr) {
Transformer* trans = gr->GetTransformer();
if (transv.is_unknown() || !transv.is_array() || transv.array_val()->Number()!=6) {
AttributeValueList* avl = new AttributeValueList();
float a00, a01, a10, a11, a20, a21;
trans->matrix(a00, a01, a10, a11, a20, a21);
avl->Append(new AttributeValue(a00));
avl->Append(new AttributeValue(a01));
avl->Append(new AttributeValue(a10));
avl->Append(new AttributeValue(a11));
avl->Append(new AttributeValue(a20));
avl->Append(new AttributeValue(a21));
ComValue retval(avl);
push_stack(retval);
} else {
float a00, a01, a10, a11, a20, a21;
AttributeValueList* avl = transv.array_val();
Iterator it;
AttributeValue* av;
avl->First(it);
av = avl->GetAttrVal(it);
a00 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a01 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a10 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a11 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a20 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a21 = av->float_val();
Transformer t(a00, a01, a10, a11, a20, a21);
*gr->GetTransformer()=t;
ComValue compval(new OverlayViewRef(comp), comp->class_symid());
push_stack(compval);
}
}
}
}
}
void calc(char* operand, Stack stack){
int one = NULL;
int two = NULL;
if (can_pop_stack){
two = pop_stack(stack);
one = pop_stack(stack);
}
else{
printf("your stack is full");
return;
}
int three;
if (strcmp(operand,"+")==0){
three = one + two;
printf("calc %d", three);
push_stack(stack, three);
}
else if (strcmp(operand,"-")==0){
three = one - two;
printf("calc %d", three);
push_stack(stack, three);
}
else if (strcmp(operand,"x")==0){
three = one * two;
printf("calc %d", three);
push_stack(stack, three);
}
else{
three = one / two;
printf("calc %d", three);
push_stack(stack, three);
}
return;
}
void deal_tmp(sqstack *operator, sqstack *operand, char ch)
{
int op1, op2;
while ( convert_operator(ch) <= convert_operator((char)top_stack(operator)) )
{
op2 = pop_stack(operand);
op1 = pop_stack(operand);
switch ( (char)pop_stack(operator) )
{
case '+' :
printf("push data: %d + %d\n", op1, op2);
push_stack(operand, op1 + op2);
break;
case '-' :
printf("push data: %d - %d\n", op1, op2);
push_stack(operand, op1 - op2);
break;
case '*' :
printf("push data: %d * %d\n", op1, op2);
push_stack(operand, op1 * op2);
break;
case '/' :
printf("push data: %d / %d\n", op1, op2);
push_stack(operand, op1 / op2);
break;
}
if ( empty_stack(operator) || ((char)pop_stack(operator) == '(') )
{
break;
}
}
push_stack(operator, (int)ch);
}
void JoinStrFunc::execute() {
ComValue listv(stack_arg(0));
static int sym_symid = symbol_add("sym");
ComValue symflagv(stack_key(sym_symid));
boolean symflag = symflagv.is_true();
reset_stack();
if (listv.is_array()) {
AttributeValueList* avl = listv.array_val();
if (avl) {
char cbuf[avl->Number()+1];
Iterator i;
int cnt=0;
for (avl->First(i); !avl->Done(i); avl->Next(i)) {
cbuf[cnt] = avl->GetAttrVal(i)->char_val();
cnt++;
}
cbuf[cnt] = '\0';
ComValue retval(symbol_add(cbuf), symflag ? ComValue::SymbolType : ComValue::StringType);
push_stack(retval);
return;
}
}
push_stack(ComValue::nullval());
}
void deal_bracket(sqstack *operator, sqstack *operand)
{
int op1, op2;
while ( (char)top_stack(operator) != '(' )
{
op2 = pop_stack(operand);
op1 = pop_stack(operand);
switch ( (char)pop_stack(operator) )
{
case '+' :
printf("push data: %d + %d\n", op1, op2);
push_stack(operand, op1 + op2);
break;
case '-' :
printf("push data: %d - %d\n", op1, op2);
push_stack(operand, op1 - op2);
break;
case '*' :
printf("push data: %d * %d\n", op1, op2);
push_stack(operand, op1 * op2);
break;
case '/' :
printf("push data: %d / %d\n", op1, op2);
push_stack(operand, op1 / op2);
break;
}
}
pop_stack(operator);
}
void WhileFunc::execute() {
static int body_symid = symbol_add("body");
static int until_symid = symbol_add("until");
static int nilchk_symid = symbol_add("nilchk");
ComValue untilflag(stack_key_post_eval(until_symid));
ComValue nilchkflag(stack_key_post_eval(nilchk_symid));
ComValue* bodyexpr = nil;
while (1) {
if (untilflag.is_false()) {
ComValue doneexpr(stack_arg_post_eval(0));
if (nilchkflag.is_false() ? doneexpr.is_false() : doneexpr.is_unknown()) break;
}
delete bodyexpr;
ComValue keybody(stack_key_post_eval(body_symid, false, ComValue::unkval(), true));
if (keybody.is_unknown() && nargsfixed()>= 2)
bodyexpr = new ComValue(stack_arg_post_eval(1));
else
bodyexpr = new ComValue(keybody);
if (untilflag.is_true()) {
ComValue doneexpr(stack_arg_post_eval(0));
if (nilchkflag.is_false() ? doneexpr.is_true() : doneexpr.is_unknown()) break;
}
}
reset_stack();
if (bodyexpr) {
push_stack(*bodyexpr);
delete bodyexpr;
} else
push_stack(ComValue::nullval());
}
void SumFunc::execute() {
ComValue vallist(stack_arg(0));
reset_stack();
if (vallist.is_type(ComValue::ArrayType)) {
AttributeValueList* avl = vallist.array_val();
AddFunc addfunc(comterp());
push_stack(ComValue::zeroval());
Iterator it;
int count = 0;
for (avl->First(it); !avl->Done(it); avl->Next(it)) {
count++;
push_stack(*avl->GetAttrVal(it));
addfunc.exec(2,0);
}
if (_meanfunc) {
DivFunc divfunc(comterp());
ComValue divisor(count, ComValue::IntType);
push_stack(divisor);
divfunc.exec(2,0);
}
} else {
push_stack(vallist);
}
}
void CreateOpenSplineFunc::execute() {
ComValue& vect = stack_arg(0);
if (!vect.is_type(ComValue::ArrayType) || vect.array_len()==0) {
reset_stack();
push_stack(ComValue::nullval());
return;
}
const int len = vect.array_len();
const int npts = len/2;
int x[npts];
int y[npts];
ALIterator i;
AttributeValueList* avl = vect.array_val();
avl->First(i);
for (int j=0; j<npts && !avl->Done(i); j++) {
x[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
y[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
}
AttributeList* al = stack_keys();
Resource::ref(al);
reset_stack();
PasteCmd* cmd = nil;
if (npts) {
BrushVar* brVar = (BrushVar*) _ed->GetState("BrushVar");
PatternVar* patVar = (PatternVar*) _ed->GetState("PatternVar");
ColorVar* colVar = (ColorVar*) _ed->GetState("ColorVar");
Transformer* rel = get_transformer(al);
ArrowVar* aVar = (ArrowVar*) _ed->GetState("ArrowVar");
ArrowOpenBSpline* openspline = new ArrowOpenBSpline(x, y, npts, aVar->Head(), aVar->Tail(),
_ed->GetViewer()->GetMagnification(), stdgraphic);
if (brVar != nil) openspline->SetBrush(brVar->GetBrush());
if (patVar != nil) openspline->SetPattern(patVar->GetPattern());
if (colVar != nil) {
openspline->FillBg(!colVar->GetBgColor()->None());
openspline->SetColors(colVar->GetFgColor(), colVar->GetBgColor());
}
openspline->SetTransformer(rel);
Unref(rel);
ArrowSplineOvComp* comp = new ArrowSplineOvComp(openspline);
comp->SetAttributeList(al);
if (PasteModeFunc::paste_mode()==0)
cmd = new PasteCmd(_ed, new Clipboard(comp));
ComValue compval(new OverlayViewRef(comp), symbol_add("ArrowSplineComp"));
push_stack(compval);
execute_log(cmd);
} else
push_stack(ComValue::nullval());
Unref(al);
}
void SymValFunc::execute() {
// return value for each symbol variable
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
ComValue* varvalues[numargs];
for (int i=0; i<numargs; i++) {
// return fully-evaluated value: expression --> symbol --> value
varvalues[i] = &stack_arg(i, false);
// lookup_symval(*varvalues[i]);
}
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++)
avl->Append(new ComValue(*varvalues[i]));
reset_stack();
push_stack(retval);
} else {
ComValue retval (*varvalues[0]);
reset_stack();
push_stack(retval);
}
}
void SymbolFunc::execute() {
// return symbol for each id argument
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
int symbol_ids[numargs];
for (int i=0; i<numargs; i++) {
ComValue& val = stack_arg(i, true);
if (val.is_char() || val.is_short() || val.is_int())
symbol_ids[i] = val.int_val();
else
symbol_ids[i] = -1;
}
reset_stack();
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++) {
ComValue* av = new ComValue(symbol_ids[i], AttributeValue::SymbolType);
av->bquote(1);
avl->Append(av);
}
push_stack(retval);
} else {
ComValue retval (symbol_ids[0], AttributeValue::SymbolType);
retval.bquote(1);
push_stack(retval);
}
}
void CreateLineFunc::execute() {
const int x0 = 0;
const int y0 = 1;
const int x1 = 2;
const int y1 = 3;
const int n = 4;
int coords[n];
ComValue& vect = stack_arg(0);
if (!vect.is_type(ComValue::ArrayType) || vect.array_len() != n) {
reset_stack();
push_stack(ComValue::nullval());
return;
}
ALIterator i;
AttributeValueList* avl = vect.array_val();
avl->First(i);
for (int j=0; j<n && !avl->Done(i); j++) {
coords[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
}
AttributeList* al = stack_keys();
Resource::ref(al);
reset_stack();
PasteCmd* cmd = nil;
if (coords[x0] != coords[x1] || coords[y0] != coords[y1]) {
BrushVar* brVar = (BrushVar*) _ed->GetState("BrushVar");
PatternVar* patVar = (PatternVar*) _ed->GetState("PatternVar");
ColorVar* colVar = (ColorVar*) _ed->GetState("ColorVar");
Transformer* rel = get_transformer(al);
ArrowVar* aVar = (ArrowVar*) _ed->GetState("ArrowVar");
ArrowLine* line = new ArrowLine(coords[x0], coords[y0], coords[x1], coords[y1], aVar->Head(), aVar->Tail(),
_ed->GetViewer()->GetMagnification(), stdgraphic);
if (brVar != nil) line->SetBrush(brVar->GetBrush());
if (colVar != nil) {
line->FillBg(!colVar->GetBgColor()->None());
line->SetColors(colVar->GetFgColor(), colVar->GetBgColor());
}
line->SetTransformer(rel);
Unref(rel);
ArrowLineOvComp* comp = new ArrowLineOvComp(line);
comp->SetAttributeList(al);
if (PasteModeFunc::paste_mode()==0)
cmd = new PasteCmd(_ed, new Clipboard(comp));
ComValue compval(new OverlayViewRef(comp), symbol_add("ArrowLineComp"));
push_stack(compval);
execute_log(cmd);
} else
push_stack(ComValue::nullval());
Unref(al);
}
void CreateEllipseFunc::execute() {
const int x0 = 0;
const int y0 = 1;
const int r1 = 2;
const int r2 = 3;
const int n = 4;
int args[n];
ComValue& vect = stack_arg(0);
if (!vect.is_type(ComValue::ArrayType) || vect.array_len() != n) {
reset_stack();
push_stack(ComValue::nullval());
return;
}
ALIterator i;
AttributeValueList* avl = vect.array_val();
avl->First(i);
for (int j=0; j<n && !avl->Done(i); j++) {
args[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
}
AttributeList* al = stack_keys();
Resource::ref(al);
reset_stack();
PasteCmd* cmd = nil;
if (args[r1] > 0 && args[r2] > 0) {
BrushVar* brVar = (BrushVar*) _ed->GetState("BrushVar");
PatternVar* patVar = (PatternVar*) _ed->GetState("PatternVar");
ColorVar* colVar = (ColorVar*) _ed->GetState("ColorVar");
Transformer* rel = get_transformer(al);
SF_Ellipse* ellipse = new SF_Ellipse(args[x0], args[y0], args[r1], args[r2], stdgraphic);
if (brVar != nil) ellipse->SetBrush(brVar->GetBrush());
if (patVar != nil) ellipse->SetPattern(patVar->GetPattern());
if (colVar != nil) {
ellipse->FillBg(!colVar->GetBgColor()->None());
ellipse->SetColors(colVar->GetFgColor(), colVar->GetBgColor());
}
ellipse->SetTransformer(rel);
Unref(rel);
EllipseOvComp* comp = new EllipseOvComp(ellipse);
comp->SetAttributeList(al);
if (PasteModeFunc::paste_mode()==0)
cmd = new PasteCmd(_ed, new Clipboard(comp));
ComValue compval( new OverlayViewRef(comp), symbol_add("EllipseComp"));
push_stack(compval);
execute_log(cmd);
} else
push_stack(ComValue::nullval());
Unref(al);
}
void CreateTextFunc::execute() {
const int x0 = 0;
const int y0 = 1;
const int n = 2;
int args[n];
ComValue& vect = stack_arg(0);
ComValue& txtv = stack_arg(1);
if (!vect.is_type(ComValue::ArrayType) || vect.array_len() != n) {
reset_stack();
push_stack(ComValue::nullval());
return;
}
ALIterator i;
AttributeValueList* avl = vect.array_val();
avl->First(i);
for (int j=0; j<n && !avl->Done(i); j++) {
args[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
}
const char* txt = symbol_pntr( txtv.symbol_ref() );
AttributeList* al = stack_keys();
Resource::ref(al);
reset_stack();
PasteCmd* cmd = nil;
if (txt) {
ColorVar* colVar = (ColorVar*) _ed->GetState("ColorVar");
FontVar* fntVar = (FontVar*) _ed->GetState("FontVar");
Transformer* rel = get_transformer(al);
TextGraphic* text = new TextGraphic(txt, stdgraphic);
if (colVar != nil) {
text->FillBg(!colVar->GetBgColor()->None());
text->SetColors(colVar->GetFgColor(), colVar->GetBgColor());
}
if (fntVar != nil) text->SetFont(fntVar->GetFont());
text->SetTransformer(new Transformer());
text->Translate(args[x0], args[y0]);
text->GetTransformer()->postmultiply(rel);
Unref(rel);
TextOvComp* comp = new TextOvComp(text);
comp->SetAttributeList(al);
if (PasteModeFunc::paste_mode()==0)
cmd = new PasteCmd(_ed, new Clipboard(comp));
ComValue compval(new OverlayViewRef(comp), symbol_add("TextComp"));
push_stack(compval);
execute_log(cmd);
} else
push_stack(ComValue::nullval());
Unref(al);
}
PCIPHEREXP __INTERNAL_FUNC__ ReverseCipherExpression(PCIPHEREXP pCipherExp) {
/*
* 再压入操作符号与操作节点时
* 链中第一个节点不压入栈
* 最后一个操作符号不压入栈
*
* 逆向式中的第一个节点肯定没有操作符号
*/
__bool bIsFirst = TRUE;
LOGIC_OPT *pOpt = NULL;
PCIPHEREXP pReverseCipherExp = NULL, *pReverseCipherExpPoint = NULL;
PCIPHEREXP pCurrCipherExp = pCipherExp;
PSTACK pOptStack = init_stack(0);
__integer i = 0, iCipherNodeCount = CountCipherNode(pCipherExp);
PSTACK pCipherExpNodeStack = init_stack(sizeof(CIPHEREXP) * iCipherNodeCount);
for (i = 0; i < iCipherNodeCount; i++) {
if (i == 0) {//舍弃第一个节点
push_stack(pOptStack, &(pCurrCipherExp->Opt), sizeof(LOGIC_OPT));
} else if (i == iCipherNodeCount-1) {
push_stack(pCipherExpNodeStack, pCurrCipherExp, sizeof(CIPHEREXP));
} else {
push_stack(pOptStack, &(pCurrCipherExp->Opt), sizeof(LOGIC_OPT));
push_stack(pCipherExpNodeStack, pCurrCipherExp, sizeof(CIPHEREXP));
}
pCurrCipherExp = pCurrCipherExp->pNextExp;
}
/*
* 首先扩充第一个节点(变量)
*/
pReverseCipherExpPoint = &pReverseCipherExp;
do {
pOpt = (LOGIC_OPT *)pop_stack(pOptStack, sizeof(LOGIC_OPT));
(*pReverseCipherExpPoint) = CreateCipherExp();
// 如果是第一个节点
if (bIsFirst) {
(*pReverseCipherExpPoint)->bNot = pCipherExp->bNot;//第一个变量是否拥有NOT操作
(*pReverseCipherExpPoint)->Opt = GenerateReverseLogicOpt(*pOpt);
bIsFirst = FALSE;
} else {
if (!pOpt)
(*pReverseCipherExpPoint)->Opt = LOGIC_NONE;
else
(*pReverseCipherExpPoint)->Opt = *pOpt;
pCurrCipherExp = (PCIPHEREXP)pop_stack(pCipherExpNodeStack, sizeof(CIPHEREXP));
(*pReverseCipherExpPoint)->bKey = pCurrCipherExp->bKey;
(*pReverseCipherExpPoint)->bNot = pCurrCipherExp->bNot;
(*pReverseCipherExpPoint)->dwVal = pCurrCipherExp->dwVal;
}/* end else */
pReverseCipherExpPoint = &((*pReverseCipherExpPoint)->pNextExp);
} while (pOpt);
free_stack(pOptStack);
free_stack(pCipherExpNodeStack);
return pReverseCipherExp;
}
void DegToRadFunc::execute() {
ComValue operandx = stack_arg(0);
reset_stack();
if (operandx.is_nil()) {
push_stack(ComValue::nullval());
return;
}
ComValue result(operandx.double_val()*2*3.1415926535897932270E0/360.);
push_stack(result);
}
void Log2Func::execute() {
ComValue operandx = stack_arg(0);
reset_stack();
if (operandx.is_nil()) {
push_stack(ComValue::nullval());
return;
}
ComValue result(log2(operandx.double_val()));
push_stack(result);
}
void PowFunc::execute() {
ComValue operandx = stack_arg(0);
ComValue operandy = stack_arg(1);
reset_stack();
if (operandx.is_nil() || operandy.is_nil()) {
push_stack(ComValue::nullval());
return;
}
ComValue result(pow(operandx.double_val(), operandy.double_val()));
push_stack(result);
}
int push_Stack(BiTree s)
{
if(s->top== size-1 || root == NULL)
return 0;
s->top++;
s->base[s->top]=root;
s->base[(s->top)*2]=root->Lchild;
push_stack(root->Lchild,s);
push_stack(root->Rchild,s);
return 1;
}
void __parser(lp_token** input,
int count)
{
success=false;
int top_state=0;
int input_index=0;
int accept_state=16;
int pop_count=0;
int action=0;
//initialize the stack at state 0
pcstack* parse_stack=new_pcstack();
push_stack(parse_stack,(void*)new_token(0,0));
while(true)
{
top_state=((lp_token*)peek_stack(parse_stack))->lex_id;
if(input_index==count)action=parse_table[top_state][12];
else if(input[input_index]->lex_id>=12)return;
else action=parse_table[top_state][input[input_index]->lex_id];
if(action==accept_state)//accept
{
action=-((lp_token*)peek_stack(parse_stack))->lex_id;
__prh(&action,parse_stack);
//printf("accept\n");
success=true;
return;
}
if(action>0)//shift
{
//printf("shift\n");
push_stack(parse_stack,(void*)new_token(action,input[input_index]->lex_val));
++input_index;
}
else if(action<0)//reduce
{
pop_count=__prh(&action,parse_stack);
if(pop_count==-1)break;//catch errors here
while(pop_count>0)
{
pop_stack(parse_stack);
--pop_count;
}
push_stack(parse_stack,(void*)new_token(parse_table[((lp_token*)peek_stack(parse_stack))->lex_id][action],0));
//printf("reduce\n");
}
else//error
{
//printf("error\n");
return;
}
}
}
void ra_checker::run_on(container_node* c) {
if (c->is_region()) {
region_node *r = static_cast<region_node*>(c);
if (r->loop_phi) {
check_phi_src(r->loop_phi, 0);
process_phi_dst(r->loop_phi);
}
} else if (c->is_depart()) {
push_stack();
} else if (c->is_repeat()) {
push_stack();
}
for (node_iterator I = c->begin(), E = c->end(); I != E; ++I) {
node *n = *I;
if(n->is_cf_inst() || n->is_fetch_inst()) {
check_op_src(n);
process_op_dst(n);
}
if (n->is_container()) {
if (n->is_alu_group()) {
check_alu_group(static_cast<alu_group_node*>(n));
} else {
container_node *nc = static_cast<container_node*>(n);
run_on(nc);
}
}
}
if (c->is_depart()) {
depart_node *r = static_cast<depart_node*>(c);
check_phi_src(r->target->phi, r->dep_id);
pop_stack();
} else if (c->is_repeat()) {
repeat_node *r = static_cast<repeat_node*>(c);
assert (r->target->loop_phi);
pop_stack();
} else if (c->is_region()) {
region_node *r = static_cast<region_node*>(c);
if (r->phi)
process_phi_dst(r->phi);
}
}
void SplitStrFunc::execute() {
ComValue symvalv(stack_arg(0));
reset_stack();
if (symvalv.is_string()) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
const char* str = symvalv.symbol_ptr();
int len = strlen(str);
for (int i=0; i<len; i++)
avl->Append(new AttributeValue(str[i]));
push_stack(retval);
} else
push_stack(ComValue::nullval());
}
void arch_prepare_thread(struct thread *t,
void asmlinkage (*thread_entry)(void *), void *arg)
{
uintptr_t stack = t->stack_current;
/* Imitate thread_entry(t) with return address of 0. thread_entry()
* is assumed to never return. */
stack = push_stack(stack, (uintptr_t)arg);
stack = push_stack(stack, (uintptr_t)0);
stack = push_stack(stack, (uintptr_t)thread_entry);
/* Make room for the registers. Ignore intial values. */
stack -= sizeof(struct pushad_regs);
t->stack_current = stack;
}
void text_para_context::start_element(xmlns_id_t ns, xml_token_t name, const xml_attrs_t& attrs)
{
xml_token_pair_t parent = push_stack(ns, name);
if (ns == NS_odf_text)
{
switch (name)
{
case XML_p:
// paragraph
xml_element_expected(parent, XMLNS_UNKNOWN_ID, XML_UNKNOWN_TOKEN);
break;
case XML_span:
{
// text span.
xml_element_expected(parent, NS_odf_text, XML_p);
flush_segment();
pstring style_name =
for_each(attrs.begin(), attrs.end(), single_attr_getter(m_pool, NS_odf_text, XML_style_name)).get_value();
m_span_stack.push_back(style_name);
}
break;
case XML_s:
// control character. ignored for now.
break;
default:
warn_unhandled();
}
}
else
warn_unhandled();
}
int main(int argc, char **argv) {
int i;
int x;
int p;
Stack stack = new_stack(argc);
for(i=0; i <= argc; i++){
if(argv[i] == NULL){
printf("you have no args %d", i);
break;
}
else if(isdigit(argv[i][0])){
p = atoi(argv[i]);
printf("arg %d\n", p);
push_stack(stack, p);
}
else if(strcmp(argv[i],"+")==0 || strcmp(argv[i],"-")==0 || strcmp(argv[i],"x")==0 || strcmp(argv[i],"/")==0){
printf("arg %s\n", argv[i]);
char* arg = argv[i];
calc(arg, stack);
}
else{
printf("args %s", argv[i]);
}
}
}
extern inline void maybe_mark_and_push(unix_socket *x)
{
if (x->protinfo.af_unix.marksweep&MARKED)
return;
x->protinfo.af_unix.marksweep|=MARKED;
push_stack(x);
}
int main(void){
Pilha my_stack;
fila my_queue;
iniciar_stack(tamanho,&my_stack);
iniciar_queue(tamanho,&my_queue);
for(register unsigned int cont = 0 ; cont < 10 ; cont ++){
push_queue(cont,&my_queue);
printf("Fila(%d):%d\n",cont+1,cont);
}
int *aux;
aux = (int*)malloc((sizeof(tamanho)));
aux = listar_queue(my_queue);
for(register unsigned int cont = 0 ; cont < 10 ; cont ++){
int valor = aux[cont];
push_stack(valor,&my_stack);
printf("Fila(%d):%d\n",cont+1,aux[cont]);
pop_queue(&my_queue);
}
int quantidade;
aux = listar_stack(my_stack,&quantidade);
for(register unsigned int cont = 0 ; cont < 10 ; cont ++){
int valor = aux[cont];
push_queue(valor,&my_queue);
printf("Fila(%d):%d\n",cont+1,aux[cont]);
}
free(aux);
}
/* virtual */ void CollisionShapeNodeVisitor::visit(CollisionShapeNode* node) {
pop_stack(node);
math::mat4 curr_matrix(matrix_stack_.top() * node->get_transform());
if (shape_index_ >= rigid_body_->shapes().size()) {
rigid_body_->shapes().push_back(RigidBodyNode::ShapeElement());
resync_ = true;
}
RigidBodyNode::ShapeElement& sh = rigid_body_->shapes().at(shape_index_);
if (sh.transform != curr_matrix) {
sh.transform = curr_matrix;
resync_ = true;
}
if (sh.shape_name != node->data.get_shape()) {
sh.shape = CollisionShapeDatabase::instance()->lookup(node->data.get_shape());
sh.shape_name = node->data.get_shape();
resync_ = true;
}
++shape_index_;
// visit children of the collision shape
if (node->has_children()) {
push_stack(curr_matrix);
for (auto child : node->children_)
child->accept(*this);
}
}
static fz_draw_state *
fz_knockout_begin(fz_draw_device *dev)
{
fz_context *ctx = dev->ctx;
fz_bbox bbox;
fz_pixmap *dest, *shape;
fz_draw_state *state = &dev->stack[dev->top];
int isolated = state->blendmode & FZ_BLEND_ISOLATED;
if ((state->blendmode & FZ_BLEND_KNOCKOUT) == 0)
return state;
state = push_stack(dev);
bbox = fz_pixmap_bbox(dev->ctx, state->dest);
bbox = fz_intersect_bbox(bbox, state->scissor);
dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox);
if (isolated)
{
fz_clear_pixmap(ctx, dest);
}
else
{
/* Find the last but one destination to copy */
int i = dev->top-1; /* i = the one on entry (i.e. the last one) */
fz_pixmap *prev = state->dest;
while (i > 0)
{
prev = dev->stack[--i].dest;
if (prev != state->dest)
break;
}
if (prev)
fz_copy_pixmap_rect(ctx, dest, prev, bbox);
else
fz_clear_pixmap(ctx, dest);
}
if (state->blendmode == 0 && isolated)
{
/* We can render direct to any existing shape plane. If there
* isn't one, we don't need to make one. */
shape = state->shape;
}
else
{
shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, shape);
}
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Knockout begin\n");
#endif
state[1].scissor = bbox;
state[1].dest = dest;
state[1].shape = shape;
state[1].blendmode &= ~FZ_BLEND_MODEMASK;
return &state[1];
}
static void
fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
{
fz_draw_device *dev = devp->user;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
fz_bbox bbox;
fz_draw_state *state = &dev->stack[dev->top];
fz_colorspace *model;
fz_context *ctx = dev->ctx;
fz_reset_gel(dev->gel, state->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
state = push_stack(dev);
model = state->dest->colorspace;
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, state->scissor);
bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(rect));
/* SumatraPDF: try to match rendering with and without display list */
if (fz_is_infinite_rect(rect))
bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(fz_bound_path(ctx, path, NULL, ctm)));
if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
{
state[1].scissor = bbox;
state[1].mask = NULL;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (rectangular) begin\n");
#endif
return;
}
fz_try(ctx)
{
state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].mask);
state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
fz_clear_pixmap(dev->ctx, state[1].dest);
if (state[1].shape)
{
state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].shape);
}
fz_scan_convert(dev->gel, even_odd, bbox, state[1].mask, NULL);
state[1].blendmode |= FZ_BLEND_ISOLATED;
state[1].scissor = bbox;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (non-rectangular) begin\n");
#endif
}
fz_catch(ctx)
{
emergency_pop_stack(dev, state);
}
}
