void n_init_decl::code_gen(status& stat, std::ostream& out)
{
	if (left != NULL)
	{
		stat.set_decl(false); // let the id node know that a variable is being declared
		left->code_gen(stat, out);
		stat.set_decl(false);
	}

	if (right != NULL) // if variable is initialised to value
	{
		if (stat.global_var())
		{
			std::stringstream amount;
			right->print(amount);
			out << "\t" << amount.str() << "\n";
		}
		else
		{
			stat.lock_register(out);
			stat.set_assign_expr();
			// evaluate assign expr
			right->code_gen(stat, out);
			stat.set_assign_var(); // let the id node know that a variable is being set to a value
			left->code_gen(stat, out);
			stat.set_assign_var();
			stat.unlock_register(out);
			stat.set_assign_expr();
		}
	}
	else if (stat.global_var())
		out << "\n";

	return;
}

void v_float::build_status(status& stat, std::ostream& out)
{
	stat.change_text_data("rdata", out);
	out << stat.data_label_gen() << ":\n";
	out << "\t.word\t" << value.i << "\n";
	return;
}

inline status wait_children(Children &cs) 
{ 
    BOOST_ASSERT(cs.size() >= 2); 

    typename Children::iterator it = cs.begin(); 
    while (it != cs.end()) 
    { 
        const status s = it->wait(); 
        ++it; 
        if (it == cs.end()) 
            return s; 
        else if (!s.exited() || s.exit_status() != EXIT_SUCCESS) 
        { 
            while (it != cs.end()) 
            { 
                it->wait(); 
                ++it; 
            } 
            return s; 
        } 
    } 

    BOOST_ASSERT(false); 
    return cs.begin()->wait(); 
} 

    template < typename K, typename V > static void visit( const K& key, const status& t, V& v )
    {
        v.apply( "t", t.timestamp );
        v.apply( "position", t.get_position() );

        // todo: quick and dirty, output as bitmask (or implement bitmask as csv type)
        v.apply( "con", t.status_response.status.con() );
        v.apply( "exec", t.status_response.status.exec() );
        v.apply( "des", t.status_response.status.des() );
        v.apply( "oslr", t.status_response.status.oslr() );
        v.apply( "cwm", t.status_response.status.cwm() );
        v.apply( "ccwm", t.status_response.status.ccwm() );
        v.apply( "upm", t.status_response.status.upm() );
        v.apply( "dwnm", t.status_response.status.dwnm() );
        
        v.apply( "cwsl", t.status_response.response_pan_status.cwsl() );
        v.apply( "ccwsl", t.status_response.response_pan_status.ccwsl() );
        v.apply( "cwhl", t.status_response.response_pan_status.cwhl() );
        v.apply( "ccwhl", t.status_response.response_pan_status.ccwhl() );
        v.apply( "pan-to", t.status_response.response_pan_status.to() );
        v.apply( "pan-de", t.status_response.response_pan_status.de() );
        
        v.apply( "usl", t.status_response.response_tilt_status.usl() );
        v.apply( "dsl", t.status_response.response_tilt_status.dsl() );
        v.apply( "uhl", t.status_response.response_tilt_status.uhl() );
        v.apply( "dhl", t.status_response.response_tilt_status.dhl() );
        v.apply( "tilt-to", t.status_response.response_tilt_status.to() );
        v.apply( "tilt-de", t.status_response.response_tilt_status.de() );
    }

/// Terminates the current process reproducing the given status.
///
/// The caller process is abruptly terminated.  In particular, no output streams
/// are flushed, no destructors are called, and no atexit(2) handlers are run.
///
/// \param status The status to "re-deliver" to the caller process.
void
process::terminate_self_with(const status& status)
{
    if (status.exited()) {
        ::_exit(status.exitstatus());
    } else {
        INV(status.signaled());
        (void)::kill(::getpid(), status.termsig());
        UNREACHABLE_MSG(F("Signal %s terminated %s but did not terminate "
                          "ourselves") % status.termsig() % status.dead_pid());
    }
}

bool operator<(status const& lhs, status const& rhs)
{
    return lhs.get_code() < rhs.get_code();
}