_daijoubu_node &
_daijoubu_node::operator=(
__in const _daijoubu_node &other
)
{
daijoubu_token_factory_ptr fact = NULL;
SERIALIZE_CALL_RECUR(m_lock);
if(this != &other) {
fact = token_factory();
if(fact->contains(m_token)) {
fact->decrement_reference(m_token);
}
daijoubu_uid_class::operator=(other);
m_children = other.m_children;
m_parent = other.m_parent;
m_token = other.m_token;
if(fact->contains(m_token)) {
fact->increment_reference(m_token);
}
}
return *this;
}
json_token &
_json_token_factory::generate(
__in type_t type,
__in_opt type_t subtype
)
{
json_token result(type, subtype);
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
if(!m_initialized) {
THROW_JSON_TOKEN_EXCEPTION(JSON_TOKEN_EXCEPTION_UNINITIALIZED);
}
if(contains(result.id())) {
THROW_JSON_TOKEN_EXCEPTION_MESSAGE(JSON_TOKEN_EXCEPTION_ALREADY_EXISTS,
"%s", result.id().to_string().c_str());
}
m_token_map.insert(std::pair<json_uuid, json_token>(result.id(), result));
TRACE_EXIT("Return Value: 0x%x", 0);
return find(result.id())->second;
}
std::string
_json_token::to_string(
__in_opt bool verbose
)
{
std::stringstream result;
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
if(verbose) {
result << json_uuid_class::to_string() << " ";
}
result << "[0x" << VALUE_AS_HEX(type_t, m_type);
if(m_subtype != INVALID_TOKEN_TYPE) {
result << ", 0x" << VALUE_AS_HEX(type_t, m_subtype);
}
result << "]";
if(!m_text.empty()) {
result << " \'" << m_text << "\' (" << m_text.size() << ")";
}
if(!m_source.empty()) {
result << " (\'" << m_source << "\' (" << m_line << "))";
}
result << " Value: " << m_value;
TRACE_EXIT("Return Value: 0x%x", 0);
return result.str();
}
std::string
_json_token_factory::to_string(
__in_opt bool verbose
)
{
std::stringstream result;
std::map<json_uuid, json_token>::iterator tok_iter;
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
if(verbose) {
result << "(" << (m_initialized ? "Initialized" : "Uninitialized") << ") ";
}
result << "Entries: " << m_token_map.size();
for(tok_iter = m_token_map.begin(); tok_iter != m_token_map.end(); ++tok_iter) {
result << std::endl;
if(verbose) {
result << json_uuid::id_as_string(tok_iter->first) << " | ";
}
result << tok_iter->second.to_string(verbose);
}
TRACE_EXIT("Return Value: 0x%x", 0);
return result.str();
}
bool
_daijoubu_node::operator==(
__in const _daijoubu_node &other
)
{
bool result;
size_t iter = 0;
SERIALIZE_CALL_RECUR(m_lock);
result = (daijoubu_uid_class::operator==(other)
&& (m_children.size() == other.m_children.size())
&& (m_parent == other.m_parent)
&& (m_token == other.m_token));
if(result) {
for(; iter < m_children.size(); ++iter) {
if(m_children.at(iter) != other.m_children.at(iter)) {
result = false;
break;
}
}
}
return result;
}
std::string
_nimble_exception::to_string(
__in_opt bool verbose
)
{
std::stringstream result;
SERIALIZE_CALL_RECUR(m_lock);
result << what();
#ifndef NDEBUG
if(verbose) {
SET_TERM_ATTRIB(result, 1, COL_FORE_YELLOW);
result << " (";
if(!m_source.empty()) {
result << m_source << ":";
}
result << m_line << ") ";
CLEAR_TERM_ATTRIB(result);
}
#else
REF_PARAM(verbose);
#endif
return CHK_STR(result.str());
}
std::wstring
_daijoubu_node::to_string(
__in_opt bool verbose
)
{
SERIALIZE_CALL_RECUR(m_lock);
return node_as_string(*this, verbose);
}
void
_daijoubu_node::child_remove(
__in size_t position
)
{
SERIALIZE_CALL_RECUR(m_lock);
m_children.erase(find(position));
}
size_t
_json_token::line(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
TRACE_EXIT("Return Value: %lu", m_line);
return m_line;
}
bool
_nasm_interface::is_source_mode(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
TRACE_EXIT("Return Value: 0x%x", m_source_mode);
return m_source_mode;
}
std::string &
_json_token::text(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
TRACE_EXIT("Return Value: \'%s\' (%lu)", m_text, m_text.size());
return m_text;
}
bool
_daijoubu_node::operator!=(
__in const _daijoubu_node &other
)
{
SERIALIZE_CALL_RECUR(m_lock);
return !(*this == other);
}
double
_json_token::value(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
TRACE_EXIT("Return Value: %g", m_value);
return m_value;
}
size_t &
_daijoubu_node::child_at(
__in size_t position
)
{
SERIALIZE_CALL_RECUR(m_lock);
return *find(position);
}
nasm_arguments
_nasm_interface::get_arguments(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
TRACE_EXIT("Return Value: 0x%x", NULL);
return m_arguments;
}
bool
_json_token_factory::is_initialized(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
TRACE_EXIT("Return Value: 0x%x", m_initialized);
return m_initialized;
}
type_t
_json_token::type(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
TRACE_EXIT("Return Value: 0x%x", m_type);
return m_type;
}
void
_nasm_interface::execute_arguemnts(void)
{
nasm_assembler assem;
nasm_disassembler disassem;
std::string output_path, output_result_path, output_source_path;
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
if((m_show_help
|| m_input_path.empty()
|| m_output_path.empty())
&& !m_show_version) {
std::cout << format_usage(true) << std::endl;
} else if(m_show_version) {
std::cout << "Version " << format_version() << std::endl;
} else {
std::cout << format_version(false, true, true) << std::endl << std::endl
<< to_string() << std::endl << std::endl;
if(!determine_file_name(output_path, m_input_path)) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_FILE_PATH_FAILURE,
"%s", m_input_path.c_str());
}
output_result_path = m_output_path + output_path;
if(m_assembler_mode) {
output_result_path += ASSEMBLY_FILE_TYPE;
assem = nasm_assembler(m_input_path, true);
assem.discover();
if(m_show_output) {
std::cout << assem.to_string() << std::endl;
}
if(m_source_mode) {
output_source_path = m_output_path + output_path + SOURCE_FILE_TYPE;
assem.write_source_annotation(output_source_path);
}
assem.write(output_result_path);
} else {
output_result_path += DISASSEMBLY_FILE_TYPE;
disassem = nasm_disassembler(m_input_path);
disassem.discover(m_output_path);
if(m_show_output) {
std::cout << disassem.to_string() << std::endl;
}
disassem.write(output_result_path);
}
}
TRACE_EXIT("Return Value: 0x%x", NULL);
}
void
_nasm_interface::process_argument(
__in nasm_arguments::iterator &argument,
__in size_t flag
)
{
std::string arg_str;
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
switch(flag) {
case FLAG_ASSEMBLER:
case FLAG_DISASSEMBLER:
if(!m_assembler_mode_set) {
m_assembler_mode_set = true;
} else {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_MUTIPLE_MODES_DEFINED,
"%s", (*argument).c_str());
}
m_assembler_mode = (flag == FLAG_ASSEMBLER);
break;
case FLAG_HELP:
m_show_help = true;
break;
case FLAG_OUTPUT:
arg_str = *argument;
if((++argument) == m_arguments.end()) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_UNDEFINED_FLAG,
"%s", arg_str.c_str());
}
if(!m_output_path.empty()) {
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_OUTPUT_PATH_REDEFINITION,
"%s", (*argument).c_str());
}
m_output_path = *argument;
break;
case FLAG_QUIET:
m_show_output = false;
break;
case FLAG_SOURCE:
m_source_mode = true;
break;
case FLAG_VERSION:
m_show_version = true;
break;
default:
THROW_NASM_INTERFACE_EXCEPTION_MESSAGE(NASM_INTERFACE_EXCEPTION_UNKNOWN_FLAG,
"%s", (*argument).c_str());
}
TRACE_EXIT("Return Value: 0x%x", NULL);
}
json_token &
_json_token_factory::operator[](
__in const json_uuid &id
)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
TRACE_EXIT("Return Value: 0x%x", 0);
return at(id);
}
void
_daijoubu_node_factory::clear(void)
{
SERIALIZE_CALL_RECUR(m_lock);
if(!m_initialized) {
THROW_DAIJOUBU_NODE_EXCEPTION(DAIJOUBU_NODE_EXCEPTION_UNINITIALIZED);
}
m_node_map.clear();
}
void
_json_token_factory::initialize(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
destroy();
m_initialized = true;
TRACE_EXIT("Return Value: 0x%x", 0);
}
void
_nasm_interface::run(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
parse_arguments();
execute_arguemnts();
TRACE_EXIT("Return Value: 0x%x", NULL);
}
size_t
_daijoubu_node_factory::size(void)
{
SERIALIZE_CALL_RECUR(m_lock);
if(!m_initialized) {
THROW_DAIJOUBU_NODE_EXCEPTION(DAIJOUBU_NODE_EXCEPTION_UNINITIALIZED);
}
return m_node_map.size();
}
void
_daijoubu_node_factory::initialize(void)
{
SERIALIZE_CALL_RECUR(m_lock);
if(m_initialized) {
THROW_DAIJOUBU_NODE_EXCEPTION(DAIJOUBU_NODE_EXCEPTION_INITIALIZED);
}
m_initialized = true;
clear();
}
void
_json_token::set_text(
__in const std::string &text
)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
m_text = text;
TRACE_EXIT("Return Value: 0x%x", 0);
}
void
_json_token::set_value(
__in double value
)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
m_value = value;
TRACE_EXIT("Return Value: 0x%x", 0);
}
void
_nasm_interface::set(
__in const nasm_arguments &arguments
)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_interface_lock);
nasm_interface::clear();
m_arguments = arguments;
TRACE_EXIT("Return Value: 0x%x", NULL);
}
void
_json_token_factory::destroy(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
if(m_initialized) {
clear();
m_initialized = false;
}
TRACE_EXIT("Return Value: 0x%x", 0);
}
void
_interpreter::clear(void)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
parser::reset();
flush_scopes();
// TODO: setup global scope here
TRACE_EXIT("Return Value: 0x%x", NULL);
}
