int main() {
Stack *pila1;
pila1 = stack_create();
stack_data(pila1)[0] = 2;
stack_data(pila1)[1] = 8;
stack_data(pila1)[2] = 14;
stack_back(pila1) = 2;
pila1 = stack_push(pila1,4);
pila1 = stack_pop(pila1);
stack_print(pila1);
int i;
for(i = 0; i<=stack_back(pila1) && stack_back(pila1) != stack_maxstack(pila1) ; i++)
stack_data(pila)[i] = 3;
pila1 = stack_reverse(pila1);
stack_print(pila1);
stack_destroy(pila1);
}
void tarjan_dfs(int u)
{
dfn[u] = low[u] = ++idx;
in_stack[u] = 1;
stack_push_back(u);
struct Edge *e = orig_edge[u];
while (e) {
if (!dfn[e->v]) {
tarjan_dfs(e->v);
if (low[e->v] < low[u]) low[u] = low[e->v];
}
else if (in_stack[e->v])
if (dfn[e->v] < low[u]) low[u] = dfn[e->v];
e = e->next;
}
if (dfn[u] == low[u]) {
scc_cnt++;
int v;
do {
v = stack_back();
stack_pop_back();
in_stack[v] = 0;
scc_id[v] = scc_cnt;
scc_size[scc_cnt]++;
} while (v != u) ;
}
}
static void JsonParser_startElem(struct JsonParser *parser, const String name, int type)
{
void *ptr = NULL;
JsonNode* parent= NULL, *node=NULL;
DEBUG_PRINT("Json_startElem %s type %d\n", name, type );
if (parser->m_nodeStack->num > 0) {
ptr = stack_back(parser->m_nodeStack);
parent = (JsonNode*) ARR_VAL(ptr);
} else {
parser->m_root = JsonNode_Create();
}
if (parent) {
char *pname = isNullorEmpty(name) ? NULL : (char*)name;
node = JsonNode_createChild(parent, pname , type);
} else {
node = parser->m_root;
}
ptr = stack_push_back(parser->m_nodeStack);
if (ptr != NULL) {
ARR_VAL(ptr) = ARR_VAL2PTR(node);
}
}
static void JsonParser_elemData(struct JsonParser *parser, const String key, const String value)
{
DEBUG_PRINT("eleme '%s' => '%s'\n", key, value);
if (parser->m_nodeStack->num > 0) {
void *ptr = stack_back(parser->m_nodeStack);
JsonNode *node = (JsonNode *) ARR_VAL(ptr);
JsonNode_setPair(node, key, value);
}
}
inline bool send_stack(STATE, CallFrame* call_frame, intptr_t literal, intptr_t count) {
Object* recv = stack_back(count);
CallSite* call_site = reinterpret_cast<CallSite*>(literal);
Arguments args(call_site->name(), recv, cNil, count,
stack_back_position(count));
stack_clear(count + 1);
call_frame->return_value = call_site->execute(state, args);
state->vm()->checkpoint(state);
CHECK_AND_PUSH(call_frame->return_value);
}
void StackInterpreter::processOpCode(const OpCode& oc)
{
++opcount_;
//handle push data by itself, doesn't play well with switch
if (oc.opcode_ == 0)
{
op_0();
return;
}
if (oc.opcode_ <= 75)
{
stack_.push_back(oc.dataRef_);
return;
}
if (oc.opcode_ < 79)
{
//op push data
stack_.push_back(oc.dataRef_);
return;
}
if (oc.opcode_ == OP_1NEGATE)
{
op_1negate();
return;
}
if (oc.opcode_ <= 96 && oc.opcode_ >= 81)
{
//op_1 - op_16
uint8_t val = oc.opcode_ - 80;
stack_.push_back(move(intToRawBinary(val)));
return;
}
//If we got this far this op code is not push data. If this is the input
//script, set the flag as per P2SH parsing rules (only push data in inputs)
if (outputScriptRef_.getSize() == 0)
onlyPushDataInInput_ = false;
switch (oc.opcode_)
{
case OP_NOP:
break;
case OP_IF:
{
BinaryRefReader brr(oc.dataRef_);
op_if(brr, false);
break;
}
case OP_NOTIF:
{
op_not();
BinaryRefReader brr(oc.dataRef_);
op_if(brr, false);
break;
}
case OP_ELSE:
//processed by opening if statement
throw ScriptException("a wild else appears");
case OP_ENDIF:
//processed by opening if statement
throw ScriptException("a wild endif appears");
case OP_VERIFY:
op_verify();
break;
case OP_TOALTSTACK:
op_toaltstack();
break;
case OP_FROMALTSTACK:
op_fromaltstack();
break;
case OP_IFDUP:
op_ifdup();
break;
case OP_2DROP:
{
stack_.pop_back();
stack_.pop_back();
break;
}
case OP_2DUP:
op_2dup();
break;
case OP_3DUP:
op_3dup();
break;
case OP_2OVER:
op_2over();
break;
case OP_DEPTH:
op_depth();
break;
case OP_DROP:
stack_.pop_back();
break;
case OP_DUP:
op_dup();
break;
case OP_NIP:
op_nip();
break;
case OP_OVER:
op_over();
break;
case OP_PICK:
op_pick();
break;
case OP_ROLL:
op_roll();
break;
case OP_ROT:
op_rot();
break;
case OP_SWAP:
op_swap();
break;
case OP_TUCK:
op_tuck();
break;
case OP_SIZE:
op_size();
break;
case OP_EQUAL:
{
op_equal();
if (onlyPushDataInInput_ && p2shScript_.getSize() != 0)
{
//check the op_equal result
op_verify();
if (!isValid_)
break;
if (flags_ & SCRIPT_VERIFY_SEGWIT)
if (p2shScript_.getSize() == 22 ||
p2shScript_.getSize() == 34)
{
auto versionByte = p2shScript_.getPtr();
if (*versionByte <= 16)
{
processSW(p2shScript_);
return;
}
}
processScript(p2shScript_, true);
}
break;
}
case OP_EQUALVERIFY:
{
op_equal();
op_verify();
break;
}
case OP_1ADD:
op_1add();
break;
case OP_1SUB:
op_1sub();
break;
case OP_NEGATE:
op_negate();
break;
case OP_ABS:
op_abs();
break;
case OP_NOT:
op_not();
break;
case OP_0NOTEQUAL:
op_0notequal();
break;
case OP_ADD:
op_add();
break;
case OP_SUB:
op_sub();
break;
case OP_BOOLAND:
op_booland();
break;
case OP_BOOLOR:
op_boolor();
break;
case OP_NUMEQUAL:
op_numequal();
break;
case OP_NUMEQUALVERIFY:
{
op_numequal();
op_verify();
break;
}
case OP_NUMNOTEQUAL:
op_numnotequal();
break;
case OP_LESSTHAN:
op_lessthan();
break;
case OP_GREATERTHAN:
op_greaterthan();
break;
case OP_LESSTHANOREQUAL:
op_lessthanorequal();
break;
case OP_GREATERTHANOREQUAL:
op_greaterthanorequal();
break;
case OP_MIN:
op_min();
break;
case OP_MAX:
op_max();
break;
case OP_WITHIN:
op_within();
break;
case OP_RIPEMD160:
op_ripemd160();
break;
case OP_SHA256:
{
//save the script if this output is a possible p2sh
if (flags_ & SCRIPT_VERIFY_P2SH_SHA256)
if (opcount_ == 1 && onlyPushDataInInput_)
p2shScript_ = stack_back();
op_sha256();
break;
}
case OP_HASH160:
{
//save the script if this output is a possible p2sh
if (flags_ & SCRIPT_VERIFY_P2SH)
if (opcount_ == 1 && onlyPushDataInInput_)
p2shScript_ = stack_back();
op_hash160();
break;
}
case OP_HASH256:
op_hash256();
break;
case OP_CODESEPARATOR:
{
opcount_ = 0;
if (outputScriptRef_.getSize() != 0)
txStubPtr_->setLastOpCodeSeparator(inputIndex_, oc.offset_);
break;
}
case OP_CHECKSIG:
op_checksig();
break;
case OP_CHECKSIGVERIFY:
{
op_checksig();
op_verify();
break;
}
case OP_CHECKMULTISIG:
op_checkmultisig();
break;
case OP_CHECKMULTISIGVERIFY:
{
op_checkmultisig();
op_verify();
}
case OP_NOP1:
break;
case OP_NOP2:
{
if (!(flags_ & SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY))
break; // not enabled; treat as a NOP
//CLTV mechanics
throw ScriptException("OP_CLTV not supported");
}
case OP_NOP3:
{
if (!(flags_ & SCRIPT_VERIFY_CHECKSEQUENCEVERIFY))
break; // not enabled; treat as a NOP
//CSV mechanics
throw ScriptException("OP_CSV not supported");
}
case OP_NOP4:
break;
case OP_NOP5:
break;
case OP_NOP6:
break;
case OP_NOP7:
break;
case OP_NOP8:
break;
case OP_NOP9:
break;
case OP_NOP10:
break;
default:
{
stringstream ss;
ss << "unknown opcode: " << (unsigned)oc.opcode_;
throw runtime_error(ss.str());
}
}
}
