From 74eed45a5aa811fe56a6a7e75366f40e6343153f Mon Sep 17 00:00:00 2001 From: Carl Niklas Rydberg Date: Sat, 20 Dec 2025 19:12:51 +0100 Subject: [PATCH] Extract PEL CLI formatting/helpers into amduat_format library --- CMakeLists.txt | 11 +- include/amduat/format/json.h | 19 + include/amduat/format/output.h | 17 + include/amduat/format/pel.h | 49 ++ include/amduat/format/ref.h | 35 + include/amduat/pel/opreg_kernel.h | 5 + include/amduat/util/hex.h | 5 + src/internal/hex.c | 30 + src/near_core/format/json.c | 73 ++ src/near_core/format/pel.c | 784 ++++++++++++++++++++ src/near_core/format/ref.c | 72 ++ src/pel_stack/opreg/kernel.c | 90 ++- src/tools/amduat_pel_cli.c | 1147 ++++------------------------- 13 files changed, 1293 insertions(+), 1044 deletions(-) create mode 100644 include/amduat/format/json.h create mode 100644 include/amduat/format/output.h create mode 100644 include/amduat/format/pel.h create mode 100644 include/amduat/format/ref.h create mode 100644 src/near_core/format/json.c create mode 100644 src/near_core/format/pel.c create mode 100644 src/near_core/format/ref.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 35571b7..0bf6a0e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,6 +82,12 @@ set(AMDUAT_ENC_SRCS src/near_core/enc/tgk1_edge.c ) +set(AMDUAT_FORMAT_SRCS + src/near_core/format/json.c + src/near_core/format/ref.c + src/near_core/format/pel.c +) + set(AMDUAT_PEL_SRCS src/kernel/pel/core.c src/pel_stack/surf/surf.c @@ -123,6 +129,9 @@ amduat_link(hash_asl1 amduat_asl amduat_util) amduat_add_lib(enc SRCS ${AMDUAT_ENC_SRCS}) amduat_link(enc amduat_asl amduat_hash_asl1 amduat_util) +amduat_add_lib(format SRCS ${AMDUAT_FORMAT_SRCS}) +amduat_link(format amduat_asl amduat_enc amduat_util) + amduat_add_lib(pel SRCS ${AMDUAT_PEL_SRCS}) amduat_link(pel amduat_asl amduat_enc amduat_hash_asl1 amduat_util) @@ -176,7 +185,7 @@ target_include_directories(amduat_pel_cli PRIVATE ${AMDUAT_INCLUDE_DIR} ) target_link_libraries(amduat_pel_cli - PRIVATE amduat_pel amduat_asl_store_fs amduat_asl amduat_enc + PRIVATE amduat_format amduat_pel amduat_asl_store_fs amduat_asl amduat_enc amduat_hash_asl1 amduat_util ) set_target_properties(amduat_pel_cli PROPERTIES OUTPUT_NAME amduat-pel) diff --git a/include/amduat/format/json.h b/include/amduat/format/json.h new file mode 100644 index 0000000..87277bb --- /dev/null +++ b/include/amduat/format/json.h @@ -0,0 +1,19 @@ +#ifndef AMDUAT_FORMAT_JSON_H +#define AMDUAT_FORMAT_JSON_H + +#include "amduat/asl/core.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +bool amduat_format_json_escape(FILE *stream, amduat_octets_t text); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AMDUAT_FORMAT_JSON_H */ diff --git a/include/amduat/format/output.h b/include/amduat/format/output.h new file mode 100644 index 0000000..995fd0b --- /dev/null +++ b/include/amduat/format/output.h @@ -0,0 +1,17 @@ +#ifndef AMDUAT_FORMAT_OUTPUT_H +#define AMDUAT_FORMAT_OUTPUT_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + AMDUAT_FORMAT_OUTPUT_TEXT = 0, + AMDUAT_FORMAT_OUTPUT_JSON = 1 +} amduat_format_output_t; + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AMDUAT_FORMAT_OUTPUT_H */ diff --git a/include/amduat/format/pel.h b/include/amduat/format/pel.h new file mode 100644 index 0000000..0880af3 --- /dev/null +++ b/include/amduat/format/pel.h @@ -0,0 +1,49 @@ +#ifndef AMDUAT_FORMAT_PEL_H +#define AMDUAT_FORMAT_PEL_H + +#include "amduat/format/output.h" +#include "amduat/format/ref.h" +#include "amduat/pel/core.h" +#include "amduat/pel/opreg_kernel.h" +#include "amduat/pel/program_dag.h" +#include "amduat/pel/surf.h" +#include "amduat/pel/trace_dag.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +const char *amduat_format_pel_status_name(amduat_pel_execution_status_t status); +const char *amduat_format_pel_error_kind_name( + amduat_pel_execution_error_kind_t kind); +const char *amduat_format_pel_node_status_name( + amduat_pel_node_trace_status_t status); +const char *amduat_format_pel_store_phase_name( + amduat_pel_store_failure_phase_t phase); +const char *amduat_format_pel_store_error_name( + amduat_pel_store_error_code_t code); +const char *amduat_format_pel_kernel_kind_name( + amduat_pel_kernel_op_kind_t kind); + +bool amduat_format_pel_program(FILE *stream, + const amduat_pel_program_t *program, + amduat_format_output_t format); + +bool amduat_format_pel_trace(FILE *stream, + const amduat_pel_trace_dag_value_t *trace, + amduat_format_output_t format, + amduat_format_ref_format_t ref_format); + +bool amduat_format_pel_result(FILE *stream, + const amduat_pel_surface_execution_result_t *result, + amduat_format_output_t format, + amduat_format_ref_format_t ref_format); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AMDUAT_FORMAT_PEL_H */ diff --git a/include/amduat/format/ref.h b/include/amduat/format/ref.h new file mode 100644 index 0000000..5a64dde --- /dev/null +++ b/include/amduat/format/ref.h @@ -0,0 +1,35 @@ +#ifndef AMDUAT_FORMAT_REF_H +#define AMDUAT_FORMAT_REF_H + +#include "amduat/asl/core.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + AMDUAT_FORMAT_REF_HEX = 0, + AMDUAT_FORMAT_REF_BYTES = 1 +} amduat_format_ref_format_t; + +/* For AMDUAT_FORMAT_REF_BYTES, output is hex of EncodedRef bytes. */ +bool amduat_format_ref_to_text(amduat_reference_t ref, + amduat_format_ref_format_t fmt, + char **out_text); + +bool amduat_format_ref_write_text(FILE *stream, + amduat_reference_t ref, + amduat_format_ref_format_t fmt); + +bool amduat_format_ref_write_json(FILE *stream, + amduat_reference_t ref, + amduat_format_ref_format_t fmt); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AMDUAT_FORMAT_REF_H */ diff --git a/include/amduat/pel/opreg_kernel.h b/include/amduat/pel/opreg_kernel.h index c1374af..455718d 100644 --- a/include/amduat/pel/opreg_kernel.h +++ b/include/amduat/pel/opreg_kernel.h @@ -50,6 +50,11 @@ const amduat_pel_kernel_op_desc_t *amduat_pel_kernel_op_lookup( amduat_octets_t name, uint32_t version); +const amduat_pel_kernel_op_desc_t *amduat_pel_kernel_op_descs( + size_t *out_len); + +const char *amduat_pel_kernel_op_name(amduat_pel_kernel_op_kind_t kind); + bool amduat_pel_kernel_op_eval( const amduat_pel_kernel_op_desc_t *desc, const amduat_artifact_t *inputs, diff --git a/include/amduat/util/hex.h b/include/amduat/util/hex.h index 84a61c2..fd1ca97 100644 --- a/include/amduat/util/hex.h +++ b/include/amduat/util/hex.h @@ -17,6 +17,11 @@ bool amduat_hex_encode_lower(const uint8_t *bytes, char *out, size_t out_len); +/* Convenience: allocates output; caller frees with free(). */ +bool amduat_hex_encode_alloc(const uint8_t *bytes, + size_t byte_len, + char **out); + /* Decodes exactly; rejects odd length or invalid hex. Accept upper/lowercase. */ bool amduat_hex_decode(const char *hex, uint8_t *out, diff --git a/src/internal/hex.c b/src/internal/hex.c index 2b50b70..5234dbf 100644 --- a/src/internal/hex.c +++ b/src/internal/hex.c @@ -49,6 +49,36 @@ bool amduat_hex_encode_lower(const uint8_t *bytes, return true; } +bool amduat_hex_encode_alloc(const uint8_t *bytes, + size_t byte_len, + char **out) { + size_t out_len; + char *buf; + + if (out != NULL) { + *out = NULL; + } + if (out == NULL) { + return false; + } + + out_len = amduat_hex_encoded_size(byte_len); + if (out_len == 0) { + return byte_len == 0; + } + + buf = (char *)malloc(out_len); + if (buf == NULL) { + return false; + } + if (!amduat_hex_encode_lower(bytes, byte_len, buf, out_len)) { + free(buf); + return false; + } + *out = buf; + return true; +} + static bool amduat_hex_nibble(char c, uint8_t *out) { if (c >= '0' && c <= '9') { *out = (uint8_t)(c - '0'); diff --git a/src/near_core/format/json.c b/src/near_core/format/json.c new file mode 100644 index 0000000..3bf3df6 --- /dev/null +++ b/src/near_core/format/json.c @@ -0,0 +1,73 @@ +#include "amduat/format/json.h" + +#include + +bool amduat_format_json_escape(FILE *stream, amduat_octets_t text) { + size_t i; + + if (stream == NULL) { + return false; + } + if (text.len != 0 && text.data == NULL) { + return false; + } + + if (fputc('"', stream) == EOF) { + return false; + } + for (i = 0; i < text.len; ++i) { + uint8_t c = text.data[i]; + switch (c) { + case '"': + if (fputs("\\\"", stream) < 0) { + return false; + } + break; + case '\\': + if (fputs("\\\\", stream) < 0) { + return false; + } + break; + case '\b': + if (fputs("\\b", stream) < 0) { + return false; + } + break; + case '\f': + if (fputs("\\f", stream) < 0) { + return false; + } + break; + case '\n': + if (fputs("\\n", stream) < 0) { + return false; + } + break; + case '\r': + if (fputs("\\r", stream) < 0) { + return false; + } + break; + case '\t': + if (fputs("\\t", stream) < 0) { + return false; + } + break; + default: + if (c < 0x20u) { + if (fprintf(stream, "\\u%04x", (unsigned int)c) < 0) { + return false; + } + } else { + if (fputc((int)c, stream) == EOF) { + return false; + } + } + break; + } + } + if (fputc('"', stream) == EOF) { + return false; + } + return true; +} diff --git a/src/near_core/format/pel.c b/src/near_core/format/pel.c new file mode 100644 index 0000000..d71c812 --- /dev/null +++ b/src/near_core/format/pel.c @@ -0,0 +1,784 @@ +#include "amduat/format/pel.h" + +#include "amduat/format/json.h" +#include "amduat/format/ref.h" +#include "amduat/util/hex.h" + +#include +#include +#include + +const char *amduat_format_pel_status_name( + amduat_pel_execution_status_t status) { + switch (status) { + case AMDUAT_PEL_EXEC_STATUS_OK: + return "OK"; + case AMDUAT_PEL_EXEC_STATUS_SCHEME_UNSUPPORTED: + return "SCHEME_UNSUPPORTED"; + case AMDUAT_PEL_EXEC_STATUS_INVALID_PROGRAM: + return "INVALID_PROGRAM"; + case AMDUAT_PEL_EXEC_STATUS_INVALID_INPUTS: + return "INVALID_INPUTS"; + case AMDUAT_PEL_EXEC_STATUS_RUNTIME_FAILED: + return "RUNTIME_FAILED"; + default: + return "UNKNOWN"; + } +} + +const char *amduat_format_pel_error_kind_name( + amduat_pel_execution_error_kind_t kind) { + switch (kind) { + case AMDUAT_PEL_EXEC_ERROR_NONE: + return "NONE"; + case AMDUAT_PEL_EXEC_ERROR_SCHEME: + return "SCHEME"; + case AMDUAT_PEL_EXEC_ERROR_PROGRAM: + return "PROGRAM"; + case AMDUAT_PEL_EXEC_ERROR_INPUTS: + return "INPUTS"; + case AMDUAT_PEL_EXEC_ERROR_RUNTIME: + return "RUNTIME"; + default: + return "UNKNOWN"; + } +} + +const char *amduat_format_pel_node_status_name( + amduat_pel_node_trace_status_t status) { + switch (status) { + case AMDUAT_PEL_NODE_TRACE_OK: + return "NODE_OK"; + case AMDUAT_PEL_NODE_TRACE_FAILED: + return "NODE_FAILED"; + case AMDUAT_PEL_NODE_TRACE_SKIPPED: + return "NODE_SKIPPED"; + default: + return "NODE_UNKNOWN"; + } +} + +const char *amduat_format_pel_store_phase_name( + amduat_pel_store_failure_phase_t phase) { + switch (phase) { + case AMDUAT_PEL_STORE_FAILURE_PROGRAM: + return "PROGRAM"; + case AMDUAT_PEL_STORE_FAILURE_INPUT: + return "INPUT"; + default: + return "UNKNOWN"; + } +} + +const char *amduat_format_pel_store_error_name( + amduat_pel_store_error_code_t code) { + switch (code) { + case AMDUAT_PEL_STORE_ERROR_NOT_FOUND: + return "NOT_FOUND"; + case AMDUAT_PEL_STORE_ERROR_INTEGRITY: + return "INTEGRITY"; + case AMDUAT_PEL_STORE_ERROR_UNSUPPORTED: + return "UNSUPPORTED"; + default: + return "UNKNOWN"; + } +} + +const char *amduat_format_pel_kernel_kind_name( + amduat_pel_kernel_op_kind_t kind) { + switch (kind) { + case AMDUAT_PEL_KERNEL_OP_CONCAT: + return "concat"; + case AMDUAT_PEL_KERNEL_OP_SLICE: + return "slice"; + case AMDUAT_PEL_KERNEL_OP_CONST: + return "const"; + case AMDUAT_PEL_KERNEL_OP_HASH_ASL1: + return "hash_asl1"; + default: + return "unknown"; + } +} + +static char *amduat_format_hex_encode(amduat_octets_t bytes) { + char *hex = NULL; + if (!amduat_hex_encode_alloc(bytes.data, bytes.len, &hex)) { + return NULL; + } + return hex; +} + +static bool amduat_format_diagnostics_text( + FILE *stream, + const char *prefix, + const amduat_pel_diagnostic_entry_t *diags, + size_t diags_len) { + size_t i; + + if (diags_len == 0) { + return true; + } + if (prefix == NULL) { + prefix = ""; + } + + for (i = 0; i < diags_len; ++i) { + char *msg_hex = amduat_format_hex_encode(diags[i].message); + if (msg_hex == NULL) { + return false; + } + fprintf(stream, "%sdiagnostic[%zu].code=%u\n", prefix, i, diags[i].code); + fprintf(stream, "%sdiagnostic[%zu].message_hex=%s\n", + prefix, i, msg_hex); + free(msg_hex); + } + return true; +} + +static bool amduat_format_diagnostics_json( + FILE *stream, + const amduat_pel_diagnostic_entry_t *diags, + size_t diags_len) { + size_t i; + + fputs("[", stream); + for (i = 0; i < diags_len; ++i) { + char *msg_hex = amduat_format_hex_encode(diags[i].message); + if (msg_hex == NULL) { + return false; + } + if (i != 0) { + fputc(',', stream); + } + fprintf(stream, "{\"code\":%u,\"message_hex\":", diags[i].code); + if (!amduat_format_json_escape( + stream, amduat_octets(msg_hex, strlen(msg_hex)))) { + free(msg_hex); + return false; + } + fputs("}", stream); + free(msg_hex); + } + fputs("]", stream); + return true; +} + +static bool amduat_format_program_text(FILE *stream, + const amduat_pel_program_t *program) { + size_t i; + + fprintf(stream, "nodes_len=%zu\n", program->nodes_len); + fprintf(stream, "roots_len=%zu\n", program->roots_len); + + for (i = 0; i < program->nodes_len; ++i) { + const amduat_pel_node_t *node = &program->nodes[i]; + size_t j; + char *params_hex; + + fprintf(stream, "node[%zu].id=%u\n", i, node->id); + fprintf(stream, "node[%zu].op.name=%.*s\n", i, + (int)node->op.name.len, + node->op.name.data ? (const char *)node->op.name.data : ""); + fprintf(stream, "node[%zu].op.version=%u\n", i, node->op.version); + fprintf(stream, "node[%zu].inputs_len=%zu\n", i, node->inputs_len); + + for (j = 0; j < node->inputs_len; ++j) { + const amduat_pel_dag_input_t *input = &node->inputs[j]; + if (input->kind == AMDUAT_PEL_DAG_INPUT_EXTERNAL) { + fprintf(stream, "node[%zu].input[%zu].kind=external\n", i, j); + fprintf(stream, + "node[%zu].input[%zu].external.input_index=%u\n", + i, j, input->value.external.input_index); + } else { + fprintf(stream, "node[%zu].input[%zu].kind=node\n", i, j); + fprintf(stream, + "node[%zu].input[%zu].node.node_id=%u\n", + i, j, input->value.node.node_id); + fprintf(stream, + "node[%zu].input[%zu].node.output_index=%u\n", + i, j, input->value.node.output_index); + } + } + + params_hex = amduat_format_hex_encode(node->params); + if (params_hex == NULL) { + return false; + } + fprintf(stream, "node[%zu].params_len=%zu\n", i, node->params.len); + fprintf(stream, "node[%zu].params_hex=%s\n", i, params_hex); + free(params_hex); + } + + for (i = 0; i < program->roots_len; ++i) { + fprintf(stream, "root[%zu].node_id=%u\n", + i, program->roots[i].node_id); + fprintf(stream, "root[%zu].output_index=%u\n", + i, program->roots[i].output_index); + } + + return true; +} + +static bool amduat_format_program_json(FILE *stream, + const amduat_pel_program_t *program) { + size_t i; + + fputs("{\"nodes\":[", stream); + for (i = 0; i < program->nodes_len; ++i) { + const amduat_pel_node_t *node = &program->nodes[i]; + size_t j; + char *params_hex; + + if (i != 0) { + fputc(',', stream); + } + fputs("{\"id\":", stream); + fprintf(stream, "%u", node->id); + fputs(",\"op\":{\"name\":", stream); + if (!amduat_format_json_escape(stream, node->op.name)) { + return false; + } + fprintf(stream, ",\"version\":%u}", node->op.version); + fputs(",\"inputs\":[", stream); + for (j = 0; j < node->inputs_len; ++j) { + const amduat_pel_dag_input_t *input = &node->inputs[j]; + if (j != 0) { + fputc(',', stream); + } + if (input->kind == AMDUAT_PEL_DAG_INPUT_EXTERNAL) { + fprintf(stream, + "{\"kind\":\"external\",\"input_index\":%u}", + input->value.external.input_index); + } else { + fprintf(stream, + "{\"kind\":\"node\",\"node_id\":%u,\"output_index\":%u}", + input->value.node.node_id, + input->value.node.output_index); + } + } + fputs("]", stream); + params_hex = amduat_format_hex_encode(node->params); + if (params_hex == NULL) { + return false; + } + fputs(",\"params_hex\":", stream); + if (!amduat_format_json_escape( + stream, amduat_octets(params_hex, strlen(params_hex)))) { + free(params_hex); + return false; + } + free(params_hex); + fputs("}", stream); + } + fputs("],\"roots\":[", stream); + for (i = 0; i < program->roots_len; ++i) { + if (i != 0) { + fputc(',', stream); + } + fprintf(stream, + "{\"node_id\":%u,\"output_index\":%u}", + program->roots[i].node_id, + program->roots[i].output_index); + } + fputs("]}", stream); + return true; +} + +bool amduat_format_pel_program(FILE *stream, + const amduat_pel_program_t *program, + amduat_format_output_t format) { + if (stream == NULL || program == NULL) { + return false; + } + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { + return amduat_format_program_text(stream, program); + } + return amduat_format_program_json(stream, program); +} + +static bool amduat_format_trace_text(FILE *stream, + const amduat_pel_trace_dag_value_t *trace, + amduat_format_ref_format_t ref_format) { + size_t i; + + fprintf(stream, "pel1_version=%u\n", trace->pel1_version); + fprintf(stream, "scheme_ref="); + if (!amduat_format_ref_write_text(stream, trace->scheme_ref, ref_format)) { + return false; + } + fputc('\n', stream); + fprintf(stream, "program_ref="); + if (!amduat_format_ref_write_text(stream, trace->program_ref, ref_format)) { + return false; + } + fputc('\n', stream); + fprintf(stream, "status=%s(%u)\n", + amduat_format_pel_status_name(trace->status), + (unsigned int)trace->status); + fprintf(stream, "error_kind=%s(%u)\n", + amduat_format_pel_error_kind_name(trace->summary.kind), + (unsigned int)trace->summary.kind); + fprintf(stream, "status_code=%u\n", + (unsigned int)trace->summary.status_code); + + fprintf(stream, "has_exec_result_ref=%s\n", + trace->has_exec_result_ref ? "true" : "false"); + if (trace->has_exec_result_ref) { + fprintf(stream, "exec_result_ref="); + if (!amduat_format_ref_write_text(stream, + trace->exec_result_ref, + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "input_refs_len=%zu\n", trace->input_refs_len); + for (i = 0; i < trace->input_refs_len; ++i) { + fprintf(stream, "input_ref[%zu]=", i); + if (!amduat_format_ref_write_text(stream, + trace->input_refs[i], + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "has_params_ref=%s\n", + trace->has_params_ref ? "true" : "false"); + if (trace->has_params_ref) { + fprintf(stream, "params_ref="); + if (!amduat_format_ref_write_text(stream, + trace->params_ref, + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "node_traces_len=%zu\n", trace->node_traces_len); + for (i = 0; i < trace->node_traces_len; ++i) { + const amduat_pel_node_trace_dag_t *node = &trace->node_traces[i]; + size_t j; + char prefix[64]; + + fprintf(stream, "node_trace[%zu].node_id=%u\n", i, node->node_id); + fprintf(stream, "node_trace[%zu].op.name=%.*s\n", i, + (int)node->op_name.len, + node->op_name.data ? (const char *)node->op_name.data : ""); + fprintf(stream, "node_trace[%zu].op.version=%u\n", i, node->op_version); + fprintf(stream, "node_trace[%zu].status=%s(%u)\n", i, + amduat_format_pel_node_status_name(node->status), + (unsigned int)node->status); + fprintf(stream, "node_trace[%zu].status_code=%u\n", i, + node->status_code); + fprintf(stream, "node_trace[%zu].output_refs_len=%zu\n", i, + node->output_refs_len); + for (j = 0; j < node->output_refs_len; ++j) { + fprintf(stream, "node_trace[%zu].output_ref[%zu]=", + i, j); + if (!amduat_format_ref_write_text(stream, + node->output_refs[j], + ref_format)) { + return false; + } + fputc('\n', stream); + } + fprintf(stream, "node_trace[%zu].diagnostics_len=%zu\n", i, + node->diagnostics_len); + snprintf(prefix, sizeof(prefix), "node_trace[%zu].", i); + if (!amduat_format_diagnostics_text(stream, + prefix, + node->diagnostics, + node->diagnostics_len)) { + return false; + } + } + + return true; +} + +static bool amduat_format_trace_json(FILE *stream, + const amduat_pel_trace_dag_value_t *trace, + amduat_format_ref_format_t ref_format) { + size_t i; + + fputs("{\"pel1_version\":", stream); + fprintf(stream, "%u", trace->pel1_version); + fputs(",\"scheme_ref\":", stream); + if (!amduat_format_ref_write_json(stream, trace->scheme_ref, ref_format)) { + return false; + } + fputs(",\"program_ref\":", stream); + if (!amduat_format_ref_write_json(stream, trace->program_ref, ref_format)) { + return false; + } + fputs(",\"status\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets(amduat_format_pel_status_name(trace->status), + strlen(amduat_format_pel_status_name(trace->status))))) { + return false; + } + fprintf(stream, ",\"status_code\":%u", + (unsigned int)trace->summary.status_code); + fputs(",\"error_kind\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets( + amduat_format_pel_error_kind_name(trace->summary.kind), + strlen(amduat_format_pel_error_kind_name(trace->summary.kind))))) { + return false; + } + fprintf(stream, ",\"error_kind_code\":%u", + (unsigned int)trace->summary.kind); + + fputs(",\"has_exec_result_ref\":", stream); + fputs(trace->has_exec_result_ref ? "true" : "false", stream); + fputs(",\"exec_result_ref\":", stream); + if (trace->has_exec_result_ref) { + if (!amduat_format_ref_write_json(stream, + trace->exec_result_ref, + ref_format)) { + return false; + } + } else { + fputs("null", stream); + } + + fputs(",\"input_refs\":[", stream); + for (i = 0; i < trace->input_refs_len; ++i) { + if (i != 0) { + fputc(',', stream); + } + if (!amduat_format_ref_write_json(stream, + trace->input_refs[i], + ref_format)) { + return false; + } + } + fputs("]", stream); + + fputs(",\"has_params_ref\":", stream); + fputs(trace->has_params_ref ? "true" : "false", stream); + fputs(",\"params_ref\":", stream); + if (trace->has_params_ref) { + if (!amduat_format_ref_write_json(stream, + trace->params_ref, + ref_format)) { + return false; + } + } else { + fputs("null", stream); + } + + fputs(",\"node_traces\":[", stream); + for (i = 0; i < trace->node_traces_len; ++i) { + const amduat_pel_node_trace_dag_t *node = &trace->node_traces[i]; + size_t j; + if (i != 0) { + fputc(',', stream); + } + fprintf(stream, "{\"node_id\":%u,", node->node_id); + fputs("\"op\":{\"name\":", stream); + if (!amduat_format_json_escape(stream, node->op_name)) { + return false; + } + fprintf(stream, ",\"version\":%u},", node->op_version); + fputs("\"status\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets(amduat_format_pel_node_status_name(node->status), + strlen(amduat_format_pel_node_status_name( + node->status))))) { + return false; + } + fprintf(stream, ",\"status_code\":%u", node->status_code); + fputs(",\"output_refs\":[", stream); + for (j = 0; j < node->output_refs_len; ++j) { + if (j != 0) { + fputc(',', stream); + } + if (!amduat_format_ref_write_json(stream, + node->output_refs[j], + ref_format)) { + return false; + } + } + fputs("],\"diagnostics\":", stream); + if (!amduat_format_diagnostics_json(stream, + node->diagnostics, + node->diagnostics_len)) { + return false; + } + fputs("}", stream); + } + fputs("]}", stream); + + return true; +} + +bool amduat_format_pel_trace(FILE *stream, + const amduat_pel_trace_dag_value_t *trace, + amduat_format_output_t format, + amduat_format_ref_format_t ref_format) { + if (stream == NULL || trace == NULL) { + return false; + } + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { + return amduat_format_trace_text(stream, trace, ref_format); + } + return amduat_format_trace_json(stream, trace, ref_format); +} + +static bool amduat_format_result_text( + FILE *stream, + const amduat_pel_surface_execution_result_t *result, + amduat_format_ref_format_t ref_format) { + size_t i; + + fprintf(stream, "pel1_version=%u\n", result->pel1_version); + fprintf(stream, "scheme_ref="); + if (!amduat_format_ref_write_text(stream, result->scheme_ref, ref_format)) { + return false; + } + fputc('\n', stream); + fprintf(stream, "program_ref="); + if (!amduat_format_ref_write_text(stream, result->program_ref, ref_format)) { + return false; + } + fputc('\n', stream); + + fprintf(stream, "status=%s(%u)\n", + amduat_format_pel_status_name(result->core_result.status), + (unsigned int)result->core_result.status); + fprintf(stream, "error_kind=%s(%u)\n", + amduat_format_pel_error_kind_name(result->core_result.summary.kind), + (unsigned int)result->core_result.summary.kind); + fprintf(stream, "status_code=%u\n", + (unsigned int)result->core_result.summary.status_code); + if (!amduat_format_diagnostics_text(stream, + "", + result->core_result.diagnostics, + result->core_result.diagnostics_len)) { + return false; + } + + fprintf(stream, "input_refs_len=%zu\n", result->input_refs_len); + for (i = 0; i < result->input_refs_len; ++i) { + fprintf(stream, "input_ref[%zu]=", i); + if (!amduat_format_ref_write_text(stream, + result->input_refs[i], + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "output_refs_len=%zu\n", result->output_refs_len); + for (i = 0; i < result->output_refs_len; ++i) { + fprintf(stream, "output_ref[%zu]=", i); + if (!amduat_format_ref_write_text(stream, + result->output_refs[i], + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "has_params_ref=%s\n", + result->has_params_ref ? "true" : "false"); + if (result->has_params_ref) { + fprintf(stream, "params_ref="); + if (!amduat_format_ref_write_text(stream, + result->params_ref, + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "has_trace_ref=%s\n", + result->has_trace_ref ? "true" : "false"); + if (result->has_trace_ref) { + fprintf(stream, "trace_ref="); + if (!amduat_format_ref_write_text(stream, + result->trace_ref, + ref_format)) { + return false; + } + fputc('\n', stream); + } + + fprintf(stream, "has_store_failure=%s\n", + result->has_store_failure ? "true" : "false"); + if (result->has_store_failure) { + fprintf(stream, "store_failure.phase=%s(%u)\n", + amduat_format_pel_store_phase_name(result->store_failure.phase), + (unsigned int)result->store_failure.phase); + fprintf(stream, "store_failure.error_code=%s(%u)\n", + amduat_format_pel_store_error_name( + result->store_failure.error_code), + (unsigned int)result->store_failure.error_code); + fprintf(stream, "store_failure.failing_ref="); + if (!amduat_format_ref_write_text( + stream, result->store_failure.failing_ref, ref_format)) { + return false; + } + fputc('\n', stream); + } + + return true; +} + +static bool amduat_format_result_json( + FILE *stream, + const amduat_pel_surface_execution_result_t *result, + amduat_format_ref_format_t ref_format) { + size_t i; + + fputs("{\"pel1_version\":", stream); + fprintf(stream, "%u", result->pel1_version); + fputs(",\"scheme_ref\":", stream); + if (!amduat_format_ref_write_json(stream, result->scheme_ref, ref_format)) { + return false; + } + fputs(",\"program_ref\":", stream); + if (!amduat_format_ref_write_json(stream, result->program_ref, ref_format)) { + return false; + } + fputs(",\"status\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets(amduat_format_pel_status_name( + result->core_result.status), + strlen(amduat_format_pel_status_name( + result->core_result.status))))) { + return false; + } + fprintf(stream, ",\"status_code\":%u", + (unsigned int)result->core_result.summary.status_code); + fputs(",\"error_kind\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets(amduat_format_pel_error_kind_name( + result->core_result.summary.kind), + strlen(amduat_format_pel_error_kind_name( + result->core_result.summary.kind))))) { + return false; + } + fprintf(stream, ",\"error_kind_code\":%u", + (unsigned int)result->core_result.summary.kind); + fputs(",\"diagnostics\":", stream); + if (!amduat_format_diagnostics_json( + stream, + result->core_result.diagnostics, + result->core_result.diagnostics_len)) { + return false; + } + + fputs(",\"input_refs\":[", stream); + for (i = 0; i < result->input_refs_len; ++i) { + if (i != 0) { + fputc(',', stream); + } + if (!amduat_format_ref_write_json(stream, + result->input_refs[i], + ref_format)) { + return false; + } + } + fputs("]", stream); + + fputs(",\"output_refs\":[", stream); + for (i = 0; i < result->output_refs_len; ++i) { + if (i != 0) { + fputc(',', stream); + } + if (!amduat_format_ref_write_json(stream, + result->output_refs[i], + ref_format)) { + return false; + } + } + fputs("]", stream); + + fputs(",\"has_params_ref\":", stream); + fputs(result->has_params_ref ? "true" : "false", stream); + fputs(",\"params_ref\":", stream); + if (result->has_params_ref) { + if (!amduat_format_ref_write_json(stream, + result->params_ref, + ref_format)) { + return false; + } + } else { + fputs("null", stream); + } + + fputs(",\"has_trace_ref\":", stream); + fputs(result->has_trace_ref ? "true" : "false", stream); + fputs(",\"trace_ref\":", stream); + if (result->has_trace_ref) { + if (!amduat_format_ref_write_json(stream, + result->trace_ref, + ref_format)) { + return false; + } + } else { + fputs("null", stream); + } + + fputs(",\"has_store_failure\":", stream); + fputs(result->has_store_failure ? "true" : "false", stream); + fputs(",\"store_failure\":", stream); + if (result->has_store_failure) { + fputs("{\"phase\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets(amduat_format_pel_store_phase_name( + result->store_failure.phase), + strlen(amduat_format_pel_store_phase_name( + result->store_failure.phase))))) { + return false; + } + fprintf(stream, ",\"phase_code\":%u", + (unsigned int)result->store_failure.phase); + fputs(",\"error_code\":", stream); + if (!amduat_format_json_escape( + stream, + amduat_octets(amduat_format_pel_store_error_name( + result->store_failure.error_code), + strlen(amduat_format_pel_store_error_name( + result->store_failure.error_code))))) { + return false; + } + fprintf(stream, ",\"error_code_id\":%u", + (unsigned int)result->store_failure.error_code); + fputs(",\"failing_ref\":", stream); + if (!amduat_format_ref_write_json(stream, + result->store_failure.failing_ref, + ref_format)) { + return false; + } + fputs("}", stream); + } else { + fputs("null", stream); + } + + fputs("}", stream); + return true; +} + +bool amduat_format_pel_result(FILE *stream, + const amduat_pel_surface_execution_result_t *result, + amduat_format_output_t format, + amduat_format_ref_format_t ref_format) { + if (stream == NULL || result == NULL) { + return false; + } + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { + return amduat_format_result_text(stream, result, ref_format); + } + return amduat_format_result_json(stream, result, ref_format); +} diff --git a/src/near_core/format/ref.c b/src/near_core/format/ref.c new file mode 100644 index 0000000..16ec6ea --- /dev/null +++ b/src/near_core/format/ref.c @@ -0,0 +1,72 @@ +#include "amduat/format/ref.h" + +#include "amduat/asl/ref_text.h" +#include "amduat/enc/asl1_core_codec.h" +#include "amduat/format/json.h" +#include "amduat/util/hex.h" + +#include +#include + +bool amduat_format_ref_to_text(amduat_reference_t ref, + amduat_format_ref_format_t fmt, + char **out_text) { + if (out_text == NULL) { + return false; + } + *out_text = NULL; + + if (fmt == AMDUAT_FORMAT_REF_HEX) { + return amduat_asl_ref_encode_hex(ref, out_text); + } + + { + amduat_octets_t encoded; + char *hex = NULL; + if (!amduat_enc_asl1_core_encode_reference_v1(ref, &encoded)) { + return false; + } + if (!amduat_hex_encode_alloc(encoded.data, encoded.len, &hex)) { + free((void *)encoded.data); + return false; + } + free((void *)encoded.data); + *out_text = hex; + return true; + } +} + +bool amduat_format_ref_write_text(FILE *stream, + amduat_reference_t ref, + amduat_format_ref_format_t fmt) { + char *ref_text = NULL; + bool ok; + + if (stream == NULL) { + return false; + } + if (!amduat_format_ref_to_text(ref, fmt, &ref_text)) { + return false; + } + ok = fputs(ref_text, stream) >= 0; + free(ref_text); + return ok; +} + +bool amduat_format_ref_write_json(FILE *stream, + amduat_reference_t ref, + amduat_format_ref_format_t fmt) { + char *ref_text = NULL; + bool ok; + + if (stream == NULL) { + return false; + } + if (!amduat_format_ref_to_text(ref, fmt, &ref_text)) { + return false; + } + ok = amduat_format_json_escape( + stream, amduat_octets(ref_text, strlen(ref_text))); + free(ref_text); + return ok; +} diff --git a/src/pel_stack/opreg/kernel.c b/src/pel_stack/opreg/kernel.c index 2190e29..dc85acc 100644 --- a/src/pel_stack/opreg/kernel.c +++ b/src/pel_stack/opreg/kernel.c @@ -22,36 +22,35 @@ static bool amduat_name_eq(amduat_octets_t name, const char *literal) { memcmp(name.data, literal, len) == 0; } -static const amduat_pel_kernel_op_desc_t k_concat_desc = { - AMDUAT_PEL_KERNEL_OP_CONCAT, - AMDUAT_PEL_KERNEL_OP_CODE_CONCAT, - 1, - SIZE_MAX, - 1 -}; - -static const amduat_pel_kernel_op_desc_t k_slice_desc = { - AMDUAT_PEL_KERNEL_OP_SLICE, - AMDUAT_PEL_KERNEL_OP_CODE_SLICE, - 1, - 1, - 1 -}; - -static const amduat_pel_kernel_op_desc_t k_const_desc = { - AMDUAT_PEL_KERNEL_OP_CONST, - AMDUAT_PEL_KERNEL_OP_CODE_CONST, - 0, - 0, - 1 -}; - -static const amduat_pel_kernel_op_desc_t k_hash_desc = { - AMDUAT_PEL_KERNEL_OP_HASH_ASL1, - AMDUAT_PEL_KERNEL_OP_CODE_HASH_ASL1, - 1, - 1, - 1 +static const amduat_pel_kernel_op_desc_t k_kernel_descs[] = { + { + AMDUAT_PEL_KERNEL_OP_CONCAT, + AMDUAT_PEL_KERNEL_OP_CODE_CONCAT, + 1, + SIZE_MAX, + 1 + }, + { + AMDUAT_PEL_KERNEL_OP_SLICE, + AMDUAT_PEL_KERNEL_OP_CODE_SLICE, + 1, + 1, + 1 + }, + { + AMDUAT_PEL_KERNEL_OP_CONST, + AMDUAT_PEL_KERNEL_OP_CODE_CONST, + 0, + 0, + 1 + }, + { + AMDUAT_PEL_KERNEL_OP_HASH_ASL1, + AMDUAT_PEL_KERNEL_OP_CODE_HASH_ASL1, + 1, + 1, + 1 + }, }; const amduat_pel_kernel_op_desc_t *amduat_pel_kernel_op_lookup( @@ -61,20 +60,43 @@ const amduat_pel_kernel_op_desc_t *amduat_pel_kernel_op_lookup( return NULL; } if (amduat_name_eq(name, AMDUAT_PEL_KERNEL_OP_CONCAT_NAME)) { - return &k_concat_desc; + return &k_kernel_descs[0]; } if (amduat_name_eq(name, AMDUAT_PEL_KERNEL_OP_SLICE_NAME)) { - return &k_slice_desc; + return &k_kernel_descs[1]; } if (amduat_name_eq(name, AMDUAT_PEL_KERNEL_OP_CONST_NAME)) { - return &k_const_desc; + return &k_kernel_descs[2]; } if (amduat_name_eq(name, AMDUAT_PEL_KERNEL_OP_HASH_ASL1_NAME)) { - return &k_hash_desc; + return &k_kernel_descs[3]; } return NULL; } +const amduat_pel_kernel_op_desc_t *amduat_pel_kernel_op_descs( + size_t *out_len) { + if (out_len != NULL) { + *out_len = sizeof(k_kernel_descs) / sizeof(k_kernel_descs[0]); + } + return k_kernel_descs; +} + +const char *amduat_pel_kernel_op_name(amduat_pel_kernel_op_kind_t kind) { + switch (kind) { + case AMDUAT_PEL_KERNEL_OP_CONCAT: + return AMDUAT_PEL_KERNEL_OP_CONCAT_NAME; + case AMDUAT_PEL_KERNEL_OP_SLICE: + return AMDUAT_PEL_KERNEL_OP_SLICE_NAME; + case AMDUAT_PEL_KERNEL_OP_CONST: + return AMDUAT_PEL_KERNEL_OP_CONST_NAME; + case AMDUAT_PEL_KERNEL_OP_HASH_ASL1: + return AMDUAT_PEL_KERNEL_OP_HASH_ASL1_NAME; + default: + return NULL; + } +} + static bool amduat_type_tags_match(const amduat_artifact_t *a, const amduat_artifact_t *b) { if (a->has_type_tag != b->has_type_tag) { diff --git a/src/tools/amduat_pel_cli.c b/src/tools/amduat_pel_cli.c index 870fde4..35f5ec2 100644 --- a/src/tools/amduat_pel_cli.c +++ b/src/tools/amduat_pel_cli.c @@ -8,6 +8,10 @@ #include "amduat/enc/pel1_result.h" #include "amduat/enc/pel_program_dag.h" #include "amduat/enc/pel_trace_dag.h" +#include "amduat/format/json.h" +#include "amduat/format/output.h" +#include "amduat/format/pel.h" +#include "amduat/format/ref.h" #include "amduat/hash/asl1.h" #include "amduat/pel/opreg_kernel.h" #include "amduat/pel/opreg_kernel_params.h" @@ -36,16 +40,6 @@ enum { static const char *const AMDUAT_PEL_CLI_DEFAULT_ROOT = ".amduat-asl"; -typedef enum { - AMDUAT_PEL_CLI_REF_HEX = 0, - AMDUAT_PEL_CLI_REF_BYTES = 1 -} amduat_pel_cli_ref_format_t; - -typedef enum { - AMDUAT_PEL_CLI_FORMAT_TEXT = 0, - AMDUAT_PEL_CLI_FORMAT_JSON = 1 -} amduat_pel_cli_output_format_t; - typedef enum { AMDUAT_PEL_CLI_IO_RAW = 0, AMDUAT_PEL_CLI_IO_ARTIFACT = 1 @@ -53,8 +47,8 @@ typedef enum { typedef struct { const char *root; - amduat_pel_cli_ref_format_t ref_format; - amduat_pel_cli_output_format_t format; + amduat_format_ref_format_t ref_format; + amduat_format_output_t format; bool quiet; } amduat_pel_cli_global_opts_t; @@ -152,16 +146,16 @@ static void amduat_pel_cli_print_usage(FILE *stream) { static bool amduat_pel_cli_parse_ref_format( const char *text, - amduat_pel_cli_ref_format_t *out_fmt) { + amduat_format_ref_format_t *out_fmt) { if (text == NULL || out_fmt == NULL) { return false; } if (strcmp(text, "hex") == 0) { - *out_fmt = AMDUAT_PEL_CLI_REF_HEX; + *out_fmt = AMDUAT_FORMAT_REF_HEX; return true; } if (strcmp(text, "bytes") == 0) { - *out_fmt = AMDUAT_PEL_CLI_REF_BYTES; + *out_fmt = AMDUAT_FORMAT_REF_BYTES; return true; } return false; @@ -169,16 +163,16 @@ static bool amduat_pel_cli_parse_ref_format( static bool amduat_pel_cli_parse_output_format( const char *text, - amduat_pel_cli_output_format_t *out_fmt) { + amduat_format_output_t *out_fmt) { if (text == NULL || out_fmt == NULL) { return false; } if (strcmp(text, "text") == 0) { - *out_fmt = AMDUAT_PEL_CLI_FORMAT_TEXT; + *out_fmt = AMDUAT_FORMAT_OUTPUT_TEXT; return true; } if (strcmp(text, "json") == 0) { - *out_fmt = AMDUAT_PEL_CLI_FORMAT_JSON; + *out_fmt = AMDUAT_FORMAT_OUTPUT_JSON; return true; } return false; @@ -201,82 +195,6 @@ static bool amduat_pel_cli_parse_io_format( return false; } -static const char *amduat_pel_cli_status_name( - amduat_pel_execution_status_t status) { - switch (status) { - case AMDUAT_PEL_EXEC_STATUS_OK: - return "OK"; - case AMDUAT_PEL_EXEC_STATUS_SCHEME_UNSUPPORTED: - return "SCHEME_UNSUPPORTED"; - case AMDUAT_PEL_EXEC_STATUS_INVALID_PROGRAM: - return "INVALID_PROGRAM"; - case AMDUAT_PEL_EXEC_STATUS_INVALID_INPUTS: - return "INVALID_INPUTS"; - case AMDUAT_PEL_EXEC_STATUS_RUNTIME_FAILED: - return "RUNTIME_FAILED"; - default: - return "UNKNOWN"; - } -} - -static const char *amduat_pel_cli_error_kind_name( - amduat_pel_execution_error_kind_t kind) { - switch (kind) { - case AMDUAT_PEL_EXEC_ERROR_NONE: - return "NONE"; - case AMDUAT_PEL_EXEC_ERROR_SCHEME: - return "SCHEME"; - case AMDUAT_PEL_EXEC_ERROR_PROGRAM: - return "PROGRAM"; - case AMDUAT_PEL_EXEC_ERROR_INPUTS: - return "INPUTS"; - case AMDUAT_PEL_EXEC_ERROR_RUNTIME: - return "RUNTIME"; - default: - return "UNKNOWN"; - } -} - -static const char *amduat_pel_cli_node_status_name( - amduat_pel_node_trace_status_t status) { - switch (status) { - case AMDUAT_PEL_NODE_TRACE_OK: - return "NODE_OK"; - case AMDUAT_PEL_NODE_TRACE_FAILED: - return "NODE_FAILED"; - case AMDUAT_PEL_NODE_TRACE_SKIPPED: - return "NODE_SKIPPED"; - default: - return "NODE_UNKNOWN"; - } -} - -static const char *amduat_pel_cli_store_phase_name( - amduat_pel_store_failure_phase_t phase) { - switch (phase) { - case AMDUAT_PEL_STORE_FAILURE_PROGRAM: - return "PROGRAM"; - case AMDUAT_PEL_STORE_FAILURE_INPUT: - return "INPUT"; - default: - return "UNKNOWN"; - } -} - -static const char *amduat_pel_cli_store_error_name( - amduat_pel_store_error_code_t code) { - switch (code) { - case AMDUAT_PEL_STORE_ERROR_NOT_FOUND: - return "NOT_FOUND"; - case AMDUAT_PEL_STORE_ERROR_INTEGRITY: - return "INTEGRITY"; - case AMDUAT_PEL_STORE_ERROR_UNSUPPORTED: - return "UNSUPPORTED"; - default: - return "UNKNOWN"; - } -} - static const char *amduat_pel_cli_store_error_str( amduat_asl_store_error_t err) { switch (err) { @@ -353,52 +271,8 @@ static bool amduat_pel_cli_read_path_once(const char *path, return amduat_asl_read_path(path, out_bytes, out_len); } -static char *amduat_pel_cli_hex_encode(amduat_octets_t bytes) { - size_t out_len; - char *out; - - out_len = amduat_hex_encoded_size(bytes.len); - out = (char *)malloc(out_len); - if (out == NULL) { - return NULL; - } - if (!amduat_hex_encode_lower(bytes.data, bytes.len, out, out_len)) { - free(out); - return NULL; - } - return out; -} - -static bool amduat_pel_cli_ref_to_text(amduat_reference_t ref, - amduat_pel_cli_ref_format_t fmt, - char **out_text) { - if (out_text == NULL) { - return false; - } - *out_text = NULL; - - if (fmt == AMDUAT_PEL_CLI_REF_HEX) { - return amduat_asl_ref_encode_hex(ref, out_text); - } - - { - amduat_octets_t encoded; - char *hex; - if (!amduat_enc_asl1_core_encode_reference_v1(ref, &encoded)) { - return false; - } - hex = amduat_pel_cli_hex_encode(encoded); - free((void *)encoded.data); - if (hex == NULL) { - return false; - } - *out_text = hex; - return true; - } -} - static bool amduat_pel_cli_ref_from_text(const char *text, - amduat_pel_cli_ref_format_t fmt, + amduat_format_ref_format_t fmt, bool *stdin_used, amduat_reference_t *out_ref) { if (text == NULL || out_ref == NULL) { @@ -406,7 +280,7 @@ static bool amduat_pel_cli_ref_from_text(const char *text, } memset(out_ref, 0, sizeof(*out_ref)); - if (fmt == AMDUAT_PEL_CLI_REF_HEX) { + if (fmt == AMDUAT_FORMAT_REF_HEX) { return amduat_asl_ref_decode_hex(text, out_ref); } @@ -446,7 +320,7 @@ static bool amduat_pel_cli_append_ref(amduat_reference_t **refs, static bool amduat_pel_cli_append_refs_from_file( const char *path, - amduat_pel_cli_ref_format_t fmt, + amduat_format_ref_format_t fmt, bool *stdin_used, amduat_reference_t **refs, size_t *refs_len) { @@ -501,74 +375,6 @@ static bool amduat_pel_cli_append_refs_from_file( return true; } -static void amduat_pel_cli_json_escape(FILE *stream, - const uint8_t *data, - size_t len) { - size_t i; - - fputc('"', stream); - for (i = 0; i < len; ++i) { - uint8_t c = data[i]; - switch (c) { - case '"': - fputs("\\\"", stream); - break; - case '\\': - fputs("\\\\", stream); - break; - case '\b': - fputs("\\b", stream); - break; - case '\f': - fputs("\\f", stream); - break; - case '\n': - fputs("\\n", stream); - break; - case '\r': - fputs("\\r", stream); - break; - case '\t': - fputs("\\t", stream); - break; - default: - if (c < 0x20) { - fprintf(stream, "\\u%04x", (unsigned int)c); - } else { - fputc((int)c, stream); - } - break; - } - } - fputc('"', stream); -} - -static bool amduat_pel_cli_print_ref_text(FILE *stream, - amduat_reference_t ref, - amduat_pel_cli_ref_format_t fmt) { - char *ref_text = NULL; - if (!amduat_pel_cli_ref_to_text(ref, fmt, &ref_text)) { - return false; - } - fputs(ref_text, stream); - free(ref_text); - return true; -} - -static bool amduat_pel_cli_print_ref_json(FILE *stream, - amduat_reference_t ref, - amduat_pel_cli_ref_format_t fmt) { - char *ref_text = NULL; - if (!amduat_pel_cli_ref_to_text(ref, fmt, &ref_text)) { - return false; - } - amduat_pel_cli_json_escape(stream, - (const uint8_t *)ref_text, - strlen(ref_text)); - free(ref_text); - return true; -} - static bool amduat_pel_cli_parse_op_name(const char *text, const char **out_name, uint32_t *out_version) { @@ -614,649 +420,6 @@ static void amduat_pel_cli_free_op_name(const char *name, const char *original) } } -static bool amduat_pel_cli_print_program_text( - FILE *stream, - const amduat_pel_program_t *program) { - size_t i; - - if (program == NULL) { - return false; - } - - fprintf(stream, "nodes_len=%zu\n", program->nodes_len); - fprintf(stream, "roots_len=%zu\n", program->roots_len); - - for (i = 0; i < program->nodes_len; ++i) { - const amduat_pel_node_t *node = &program->nodes[i]; - size_t j; - char *params_hex; - - fprintf(stream, "node[%zu].id=%u\n", i, node->id); - fprintf(stream, "node[%zu].op.name=%.*s\n", i, - (int)node->op.name.len, - node->op.name.data ? (const char *)node->op.name.data : ""); - fprintf(stream, "node[%zu].op.version=%u\n", i, node->op.version); - fprintf(stream, "node[%zu].inputs_len=%zu\n", i, node->inputs_len); - - for (j = 0; j < node->inputs_len; ++j) { - const amduat_pel_dag_input_t *input = &node->inputs[j]; - if (input->kind == AMDUAT_PEL_DAG_INPUT_EXTERNAL) { - fprintf(stream, "node[%zu].input[%zu].kind=external\n", i, j); - fprintf(stream, - "node[%zu].input[%zu].external.input_index=%u\n", - i, j, input->value.external.input_index); - } else { - fprintf(stream, "node[%zu].input[%zu].kind=node\n", i, j); - fprintf(stream, - "node[%zu].input[%zu].node.node_id=%u\n", - i, j, input->value.node.node_id); - fprintf(stream, - "node[%zu].input[%zu].node.output_index=%u\n", - i, j, input->value.node.output_index); - } - } - - params_hex = amduat_pel_cli_hex_encode(node->params); - if (params_hex == NULL) { - return false; - } - fprintf(stream, "node[%zu].params_len=%zu\n", i, node->params.len); - fprintf(stream, "node[%zu].params_hex=%s\n", i, params_hex); - free(params_hex); - } - - for (i = 0; i < program->roots_len; ++i) { - fprintf(stream, "root[%zu].node_id=%u\n", - i, program->roots[i].node_id); - fprintf(stream, "root[%zu].output_index=%u\n", - i, program->roots[i].output_index); - } - - return true; -} - -static bool amduat_pel_cli_print_program_json( - FILE *stream, - const amduat_pel_program_t *program) { - size_t i; - - if (program == NULL) { - return false; - } - - fputs("{\"nodes\":[", stream); - for (i = 0; i < program->nodes_len; ++i) { - const amduat_pel_node_t *node = &program->nodes[i]; - size_t j; - char *params_hex; - - if (i != 0) { - fputc(',', stream); - } - fputs("{\"id\":", stream); - fprintf(stream, "%u", node->id); - fputs(",\"op\":{\"name\":", stream); - amduat_pel_cli_json_escape(stream, - node->op.name.data, - node->op.name.len); - fprintf(stream, ",\"version\":%u}", node->op.version); - fputs(",\"inputs\":[", stream); - for (j = 0; j < node->inputs_len; ++j) { - const amduat_pel_dag_input_t *input = &node->inputs[j]; - if (j != 0) { - fputc(',', stream); - } - if (input->kind == AMDUAT_PEL_DAG_INPUT_EXTERNAL) { - fprintf(stream, - "{\"kind\":\"external\",\"input_index\":%u}", - input->value.external.input_index); - } else { - fprintf(stream, - "{\"kind\":\"node\",\"node_id\":%u,\"output_index\":%u}", - input->value.node.node_id, - input->value.node.output_index); - } - } - fputs("]", stream); - params_hex = amduat_pel_cli_hex_encode(node->params); - if (params_hex == NULL) { - return false; - } - fputs(",\"params_hex\":", stream); - amduat_pel_cli_json_escape(stream, - (const uint8_t *)params_hex, - strlen(params_hex)); - free(params_hex); - fputs("}", stream); - } - fputs("],\"roots\":[", stream); - for (i = 0; i < program->roots_len; ++i) { - if (i != 0) { - fputc(',', stream); - } - fprintf(stream, - "{\"node_id\":%u,\"output_index\":%u}", - program->roots[i].node_id, - program->roots[i].output_index); - } - fputs("]}", stream); - return true; -} - -static bool amduat_pel_cli_print_diagnostics_text( - FILE *stream, - const char *prefix, - const amduat_pel_diagnostic_entry_t *diags, - size_t diags_len) { - size_t i; - - if (diags_len == 0) { - return true; - } - if (prefix == NULL) { - prefix = ""; - } - - for (i = 0; i < diags_len; ++i) { - char *msg_hex = amduat_pel_cli_hex_encode(diags[i].message); - if (msg_hex == NULL) { - return false; - } - fprintf(stream, "%sdiagnostic[%zu].code=%u\n", prefix, i, diags[i].code); - fprintf(stream, "%sdiagnostic[%zu].message_hex=%s\n", - prefix, i, msg_hex); - free(msg_hex); - } - return true; -} - -static bool amduat_pel_cli_print_diagnostics_json( - FILE *stream, - const amduat_pel_diagnostic_entry_t *diags, - size_t diags_len) { - size_t i; - - fputs("[", stream); - for (i = 0; i < diags_len; ++i) { - char *msg_hex = amduat_pel_cli_hex_encode(diags[i].message); - if (msg_hex == NULL) { - return false; - } - if (i != 0) { - fputc(',', stream); - } - fprintf(stream, "{\"code\":%u,\"message_hex\":", diags[i].code); - amduat_pel_cli_json_escape(stream, - (const uint8_t *)msg_hex, - strlen(msg_hex)); - fputs("}", stream); - free(msg_hex); - } - fputs("]", stream); - return true; -} - -static bool amduat_pel_cli_print_trace_text( - FILE *stream, - const amduat_pel_trace_dag_value_t *trace, - amduat_pel_cli_ref_format_t ref_format) { - size_t i; - - if (trace == NULL) { - return false; - } - - fprintf(stream, "pel1_version=%u\n", trace->pel1_version); - fprintf(stream, "scheme_ref="); - if (!amduat_pel_cli_print_ref_text(stream, trace->scheme_ref, ref_format)) { - return false; - } - fputc('\n', stream); - fprintf(stream, "program_ref="); - if (!amduat_pel_cli_print_ref_text(stream, trace->program_ref, ref_format)) { - return false; - } - fputc('\n', stream); - fprintf(stream, "status=%s(%u)\n", - amduat_pel_cli_status_name(trace->status), - (unsigned int)trace->status); - fprintf(stream, "error_kind=%s(%u)\n", - amduat_pel_cli_error_kind_name(trace->summary.kind), - (unsigned int)trace->summary.kind); - fprintf(stream, "status_code=%u\n", - (unsigned int)trace->summary.status_code); - - fprintf(stream, "has_exec_result_ref=%s\n", - trace->has_exec_result_ref ? "true" : "false"); - if (trace->has_exec_result_ref) { - fprintf(stream, "exec_result_ref="); - if (!amduat_pel_cli_print_ref_text(stream, - trace->exec_result_ref, - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "input_refs_len=%zu\n", trace->input_refs_len); - for (i = 0; i < trace->input_refs_len; ++i) { - fprintf(stream, "input_ref[%zu]=", i); - if (!amduat_pel_cli_print_ref_text(stream, - trace->input_refs[i], - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "has_params_ref=%s\n", - trace->has_params_ref ? "true" : "false"); - if (trace->has_params_ref) { - fprintf(stream, "params_ref="); - if (!amduat_pel_cli_print_ref_text(stream, - trace->params_ref, - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "node_traces_len=%zu\n", trace->node_traces_len); - for (i = 0; i < trace->node_traces_len; ++i) { - const amduat_pel_node_trace_dag_t *node = &trace->node_traces[i]; - size_t j; - - fprintf(stream, "node_trace[%zu].node_id=%u\n", i, node->node_id); - fprintf(stream, "node_trace[%zu].op.name=%.*s\n", i, - (int)node->op_name.len, - node->op_name.data ? (const char *)node->op_name.data : ""); - fprintf(stream, "node_trace[%zu].op.version=%u\n", i, node->op_version); - fprintf(stream, "node_trace[%zu].status=%s(%u)\n", i, - amduat_pel_cli_node_status_name(node->status), - (unsigned int)node->status); - fprintf(stream, "node_trace[%zu].status_code=%u\n", i, - node->status_code); - fprintf(stream, "node_trace[%zu].output_refs_len=%zu\n", i, - node->output_refs_len); - for (j = 0; j < node->output_refs_len; ++j) { - fprintf(stream, "node_trace[%zu].output_ref[%zu]=", - i, j); - if (!amduat_pel_cli_print_ref_text(stream, - node->output_refs[j], - ref_format)) { - return false; - } - fputc('\n', stream); - } - { - char prefix[64]; - fprintf(stream, "node_trace[%zu].diagnostics_len=%zu\n", i, - node->diagnostics_len); - snprintf(prefix, sizeof(prefix), "node_trace[%zu].", i); - if (!amduat_pel_cli_print_diagnostics_text( - stream, - prefix, - node->diagnostics, - node->diagnostics_len)) { - return false; - } - } - } - - return true; -} - -static bool amduat_pel_cli_print_trace_json( - FILE *stream, - const amduat_pel_trace_dag_value_t *trace, - amduat_pel_cli_ref_format_t ref_format) { - size_t i; - - if (trace == NULL) { - return false; - } - - fputs("{\"pel1_version\":", stream); - fprintf(stream, "%u", trace->pel1_version); - fputs(",\"scheme_ref\":", stream); - if (!amduat_pel_cli_print_ref_json(stream, trace->scheme_ref, ref_format)) { - return false; - } - fputs(",\"program_ref\":", stream); - if (!amduat_pel_cli_print_ref_json(stream, trace->program_ref, ref_format)) { - return false; - } - fputs(",\"status\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_status_name(trace->status), - strlen(amduat_pel_cli_status_name(trace->status))); - fprintf(stream, ",\"status_code\":%u", - (unsigned int)trace->summary.status_code); - fputs(",\"error_kind\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_error_kind_name(trace->summary.kind), - strlen(amduat_pel_cli_error_kind_name(trace->summary.kind))); - fprintf(stream, ",\"error_kind_code\":%u", - (unsigned int)trace->summary.kind); - - fputs(",\"has_exec_result_ref\":", stream); - fputs(trace->has_exec_result_ref ? "true" : "false", stream); - fputs(",\"exec_result_ref\":", stream); - if (trace->has_exec_result_ref) { - if (!amduat_pel_cli_print_ref_json(stream, - trace->exec_result_ref, - ref_format)) { - return false; - } - } else { - fputs("null", stream); - } - - fputs(",\"input_refs\":[", stream); - for (i = 0; i < trace->input_refs_len; ++i) { - if (i != 0) { - fputc(',', stream); - } - if (!amduat_pel_cli_print_ref_json(stream, - trace->input_refs[i], - ref_format)) { - return false; - } - } - fputs("]", stream); - - fputs(",\"has_params_ref\":", stream); - fputs(trace->has_params_ref ? "true" : "false", stream); - fputs(",\"params_ref\":", stream); - if (trace->has_params_ref) { - if (!amduat_pel_cli_print_ref_json(stream, - trace->params_ref, - ref_format)) { - return false; - } - } else { - fputs("null", stream); - } - - fputs(",\"node_traces\":[", stream); - for (i = 0; i < trace->node_traces_len; ++i) { - const amduat_pel_node_trace_dag_t *node = &trace->node_traces[i]; - size_t j; - if (i != 0) { - fputc(',', stream); - } - fprintf(stream, "{\"node_id\":%u,", node->node_id); - fputs("\"op\":{\"name\":", stream); - amduat_pel_cli_json_escape(stream, node->op_name.data, node->op_name.len); - fprintf(stream, ",\"version\":%u},", node->op_version); - fputs("\"status\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_node_status_name(node->status), - strlen(amduat_pel_cli_node_status_name(node->status))); - fprintf(stream, ",\"status_code\":%u", node->status_code); - fputs(",\"output_refs\":[", stream); - for (j = 0; j < node->output_refs_len; ++j) { - if (j != 0) { - fputc(',', stream); - } - if (!amduat_pel_cli_print_ref_json(stream, - node->output_refs[j], - ref_format)) { - return false; - } - } - fputs("],\"diagnostics\":", stream); - if (!amduat_pel_cli_print_diagnostics_json(stream, - node->diagnostics, - node->diagnostics_len)) { - return false; - } - fputs("}", stream); - } - fputs("]}", stream); - - return true; -} - -static bool amduat_pel_cli_print_result_text( - FILE *stream, - const amduat_pel_surface_execution_result_t *result, - amduat_pel_cli_ref_format_t ref_format) { - size_t i; - - if (result == NULL) { - return false; - } - - fprintf(stream, "pel1_version=%u\n", result->pel1_version); - fprintf(stream, "scheme_ref="); - if (!amduat_pel_cli_print_ref_text(stream, result->scheme_ref, ref_format)) { - return false; - } - fputc('\n', stream); - fprintf(stream, "program_ref="); - if (!amduat_pel_cli_print_ref_text(stream, result->program_ref, ref_format)) { - return false; - } - fputc('\n', stream); - - fprintf(stream, "status=%s(%u)\n", - amduat_pel_cli_status_name(result->core_result.status), - (unsigned int)result->core_result.status); - fprintf(stream, "error_kind=%s(%u)\n", - amduat_pel_cli_error_kind_name(result->core_result.summary.kind), - (unsigned int)result->core_result.summary.kind); - fprintf(stream, "status_code=%u\n", - (unsigned int)result->core_result.summary.status_code); - if (!amduat_pel_cli_print_diagnostics_text( - stream, - "", - result->core_result.diagnostics, - result->core_result.diagnostics_len)) { - return false; - } - - fprintf(stream, "input_refs_len=%zu\n", result->input_refs_len); - for (i = 0; i < result->input_refs_len; ++i) { - fprintf(stream, "input_ref[%zu]=", i); - if (!amduat_pel_cli_print_ref_text(stream, - result->input_refs[i], - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "output_refs_len=%zu\n", result->output_refs_len); - for (i = 0; i < result->output_refs_len; ++i) { - fprintf(stream, "output_ref[%zu]=", i); - if (!amduat_pel_cli_print_ref_text(stream, - result->output_refs[i], - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "has_params_ref=%s\n", - result->has_params_ref ? "true" : "false"); - if (result->has_params_ref) { - fprintf(stream, "params_ref="); - if (!amduat_pel_cli_print_ref_text(stream, - result->params_ref, - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "has_trace_ref=%s\n", - result->has_trace_ref ? "true" : "false"); - if (result->has_trace_ref) { - fprintf(stream, "trace_ref="); - if (!amduat_pel_cli_print_ref_text(stream, - result->trace_ref, - ref_format)) { - return false; - } - fputc('\n', stream); - } - - fprintf(stream, "has_store_failure=%s\n", - result->has_store_failure ? "true" : "false"); - if (result->has_store_failure) { - fprintf(stream, "store_failure.phase=%s(%u)\n", - amduat_pel_cli_store_phase_name(result->store_failure.phase), - (unsigned int)result->store_failure.phase); - fprintf(stream, "store_failure.error_code=%s(%u)\n", - amduat_pel_cli_store_error_name(result->store_failure.error_code), - (unsigned int)result->store_failure.error_code); - fprintf(stream, "store_failure.failing_ref="); - if (!amduat_pel_cli_print_ref_text( - stream, result->store_failure.failing_ref, ref_format)) { - return false; - } - fputc('\n', stream); - } - - return true; -} - -static bool amduat_pel_cli_print_result_json( - FILE *stream, - const amduat_pel_surface_execution_result_t *result, - amduat_pel_cli_ref_format_t ref_format) { - size_t i; - - if (result == NULL) { - return false; - } - - fputs("{\"pel1_version\":", stream); - fprintf(stream, "%u", result->pel1_version); - fputs(",\"scheme_ref\":", stream); - if (!amduat_pel_cli_print_ref_json(stream, result->scheme_ref, ref_format)) { - return false; - } - fputs(",\"program_ref\":", stream); - if (!amduat_pel_cli_print_ref_json(stream, result->program_ref, ref_format)) { - return false; - } - fputs(",\"status\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_status_name(result->core_result.status), - strlen(amduat_pel_cli_status_name(result->core_result.status))); - fprintf(stream, ",\"status_code\":%u", - (unsigned int)result->core_result.summary.status_code); - fputs(",\"error_kind\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_error_kind_name( - result->core_result.summary.kind), - strlen(amduat_pel_cli_error_kind_name( - result->core_result.summary.kind))); - fprintf(stream, ",\"error_kind_code\":%u", - (unsigned int)result->core_result.summary.kind); - fputs(",\"diagnostics\":", stream); - if (!amduat_pel_cli_print_diagnostics_json( - stream, - result->core_result.diagnostics, - result->core_result.diagnostics_len)) { - return false; - } - - fputs(",\"input_refs\":[", stream); - for (i = 0; i < result->input_refs_len; ++i) { - if (i != 0) { - fputc(',', stream); - } - if (!amduat_pel_cli_print_ref_json(stream, - result->input_refs[i], - ref_format)) { - return false; - } - } - fputs("]", stream); - - fputs(",\"output_refs\":[", stream); - for (i = 0; i < result->output_refs_len; ++i) { - if (i != 0) { - fputc(',', stream); - } - if (!amduat_pel_cli_print_ref_json(stream, - result->output_refs[i], - ref_format)) { - return false; - } - } - fputs("]", stream); - - fputs(",\"has_params_ref\":", stream); - fputs(result->has_params_ref ? "true" : "false", stream); - fputs(",\"params_ref\":", stream); - if (result->has_params_ref) { - if (!amduat_pel_cli_print_ref_json(stream, - result->params_ref, - ref_format)) { - return false; - } - } else { - fputs("null", stream); - } - - fputs(",\"has_trace_ref\":", stream); - fputs(result->has_trace_ref ? "true" : "false", stream); - fputs(",\"trace_ref\":", stream); - if (result->has_trace_ref) { - if (!amduat_pel_cli_print_ref_json(stream, - result->trace_ref, - ref_format)) { - return false; - } - } else { - fputs("null", stream); - } - - fputs(",\"has_store_failure\":", stream); - fputs(result->has_store_failure ? "true" : "false", stream); - fputs(",\"store_failure\":", stream); - if (result->has_store_failure) { - fputs("{\"phase\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_store_phase_name( - result->store_failure.phase), - strlen(amduat_pel_cli_store_phase_name(result->store_failure.phase))); - fprintf(stream, ",\"phase_code\":%u", - (unsigned int)result->store_failure.phase); - fputs(",\"error_code\":", stream); - amduat_pel_cli_json_escape( - stream, - (const uint8_t *)amduat_pel_cli_store_error_name( - result->store_failure.error_code), - strlen(amduat_pel_cli_store_error_name( - result->store_failure.error_code))); - fprintf(stream, ",\"error_code_id\":%u", - (unsigned int)result->store_failure.error_code); - fputs(",\"failing_ref\":", stream); - if (!amduat_pel_cli_print_ref_json(stream, - result->store_failure.failing_ref, - ref_format)) { - return false; - } - fputs("}", stream); - } else { - fputs("null", stream); - } - - fputs("}", stream); - return true; -} - static int amduat_pel_cli_cmd_run(int argc, char **argv, const amduat_pel_cli_global_opts_t *global) { @@ -1266,8 +429,8 @@ static int amduat_pel_cli_cmd_run(int argc, const char *inputs_file = NULL; const char **input_ref_texts = NULL; size_t input_ref_texts_len = 0; - amduat_pel_cli_ref_format_t ref_format; - amduat_pel_cli_output_format_t format; + amduat_format_ref_format_t ref_format; + amduat_format_output_t format; const char *root; bool quiet; bool has_params_ref = false; @@ -1495,14 +658,14 @@ static int amduat_pel_cli_cmd_run(int argc, if (!quiet) { fprintf(stderr, "root=%s\n", root); fprintf(stderr, "program_ref="); - if (!amduat_pel_cli_print_ref_text(stderr, program_ref, ref_format)) { + if (!amduat_format_ref_write_text(stderr, program_ref, ref_format)) { fprintf(stderr, "\n"); } else { fputc('\n', stderr); } if (has_params_ref) { fprintf(stderr, "params_ref="); - if (!amduat_pel_cli_print_ref_text(stderr, params_ref, ref_format)) { + if (!amduat_format_ref_write_text(stderr, params_ref, ref_format)) { fprintf(stderr, "\n"); } else { fputc('\n', stderr); @@ -1510,10 +673,10 @@ static int amduat_pel_cli_cmd_run(int argc, } if (has_result_value) { fprintf(stderr, "status=%s(%u)\n", - amduat_pel_cli_status_name(result_value.core_result.status), + amduat_format_pel_status_name(result_value.core_result.status), (unsigned int)result_value.core_result.status); fprintf(stderr, "error_kind=%s(%u)\n", - amduat_pel_cli_error_kind_name( + amduat_format_pel_error_kind_name( result_value.core_result.summary.kind), (unsigned int)result_value.core_result.summary.kind); fprintf(stderr, "status_code=%u\n", @@ -1521,9 +684,9 @@ static int amduat_pel_cli_cmd_run(int argc, } } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(stdout, "result_ref="); - if (!amduat_pel_cli_print_ref_text(stdout, result_ref, ref_format)) { + if (!amduat_format_ref_write_text(stdout, result_ref, ref_format)) { fprintf(stderr, "error: failed to encode result ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; goto run_cleanup; @@ -1531,7 +694,7 @@ static int amduat_pel_cli_cmd_run(int argc, fputc('\n', stdout); if (has_trace_ref) { fprintf(stdout, "trace_ref="); - if (!amduat_pel_cli_print_ref_text(stdout, trace_ref, ref_format)) { + if (!amduat_format_ref_write_text(stdout, trace_ref, ref_format)) { fprintf(stderr, "error: failed to encode trace ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; goto run_cleanup; @@ -1540,9 +703,9 @@ static int amduat_pel_cli_cmd_run(int argc, } for (i = 0; i < (int)output_refs_len; ++i) { fprintf(stdout, "output_ref[%d]=", i); - if (!amduat_pel_cli_print_ref_text(stdout, - output_refs[i], - ref_format)) { + if (!amduat_format_ref_write_text(stdout, + output_refs[i], + ref_format)) { fprintf(stderr, "error: failed to encode output ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; goto run_cleanup; @@ -1551,16 +714,16 @@ static int amduat_pel_cli_cmd_run(int argc, } } else { fputs("{\"ref_format\":\"", stdout); - fputs(ref_format == AMDUAT_PEL_CLI_REF_HEX ? "hex" : "bytes", stdout); + fputs(ref_format == AMDUAT_FORMAT_REF_HEX ? "hex" : "bytes", stdout); fputs("\",\"result_ref\":", stdout); - if (!amduat_pel_cli_print_ref_json(stdout, result_ref, ref_format)) { + if (!amduat_format_ref_write_json(stdout, result_ref, ref_format)) { fprintf(stderr, "error: failed to encode result ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; goto run_cleanup; } fputs(",\"trace_ref\":", stdout); if (has_trace_ref) { - if (!amduat_pel_cli_print_ref_json(stdout, trace_ref, ref_format)) { + if (!amduat_format_ref_write_json(stdout, trace_ref, ref_format)) { fprintf(stderr, "error: failed to encode trace ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; goto run_cleanup; @@ -1573,9 +736,9 @@ static int amduat_pel_cli_cmd_run(int argc, if (i != 0) { fputc(',', stdout); } - if (!amduat_pel_cli_print_ref_json(stdout, - output_refs[i], - ref_format)) { + if (!amduat_format_ref_write_json(stdout, + output_refs[i], + ref_format)) { fprintf(stderr, "error: failed to encode output ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; goto run_cleanup; @@ -1615,7 +778,7 @@ static int amduat_pel_cli_cmd_exec(int argc, size_t input_paths_len = 0; amduat_pel_cli_io_format_t input_format = AMDUAT_PEL_CLI_IO_RAW; amduat_pel_cli_io_format_t output_format = AMDUAT_PEL_CLI_IO_RAW; - amduat_pel_cli_output_format_t format; + amduat_format_output_t format; const char *output_dir = "."; const char *result_out = "-"; amduat_pel_program_t program; @@ -1822,12 +985,12 @@ static int amduat_pel_cli_cmd_exec(int argc, } } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(out_stream, "status=%s(%u)\n", - amduat_pel_cli_status_name(result.status), + amduat_format_pel_status_name(result.status), (unsigned int)result.status); fprintf(out_stream, "error_kind=%s(%u)\n", - amduat_pel_cli_error_kind_name(result.summary.kind), + amduat_format_pel_error_kind_name(result.summary.kind), (unsigned int)result.summary.kind); fprintf(out_stream, "status_code=%u\n", (unsigned int)result.summary.status_code); @@ -1838,17 +1001,18 @@ static int amduat_pel_cli_cmd_exec(int argc, } } else { fputs("{\"status\":", out_stream); - amduat_pel_cli_json_escape( + amduat_format_json_escape( out_stream, - (const uint8_t *)amduat_pel_cli_status_name(result.status), - strlen(amduat_pel_cli_status_name(result.status))); + amduat_octets(amduat_format_pel_status_name(result.status), + strlen(amduat_format_pel_status_name(result.status)))); fprintf(out_stream, ",\"status_code\":%u", (unsigned int)result.summary.status_code); fputs(",\"error_kind\":", out_stream); - amduat_pel_cli_json_escape( + amduat_format_json_escape( out_stream, - (const uint8_t *)amduat_pel_cli_error_kind_name(result.summary.kind), - strlen(amduat_pel_cli_error_kind_name(result.summary.kind))); + amduat_octets(amduat_format_pel_error_kind_name(result.summary.kind), + strlen(amduat_format_pel_error_kind_name( + result.summary.kind)))); fprintf(out_stream, ",\"error_kind_code\":%u", (unsigned int)result.summary.kind); fputs(",\"output_paths\":[", out_stream); @@ -1864,9 +1028,8 @@ static int amduat_pel_cli_cmd_exec(int argc, exit_code = AMDUAT_PEL_CLI_EXIT_IO; goto exec_cleanup; } - amduat_pel_cli_json_escape(out_stream, - (const uint8_t *)path_buf, - strlen(path_buf)); + amduat_format_json_escape( + out_stream, amduat_octets(path_buf, strlen(path_buf))); } } fputs("]}\n", out_stream); @@ -1898,8 +1061,8 @@ static int amduat_pel_cli_cmd_validate( const char *program_ref_text = NULL; bool input_path_set = false; amduat_pel_cli_io_format_t input_format = AMDUAT_PEL_CLI_IO_RAW; - amduat_pel_cli_output_format_t format; - amduat_pel_cli_ref_format_t ref_format; + amduat_format_output_t format; + amduat_format_ref_format_t ref_format; const char *root; bool has_expect_type_tag = false; amduat_type_tag_t expect_type_tag; @@ -2068,7 +1231,7 @@ static int amduat_pel_cli_cmd_validate( amduat_enc_pel_program_dag_free(&program); amduat_pel_cli_free_artifact(&artifact); - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(stdout, "valid=%s\n", ok ? "true" : "false"); } else { fprintf(stdout, "{\"valid\":%s}\n", ok ? "true" : "false"); @@ -2088,8 +1251,8 @@ static int amduat_pel_cli_cmd_program_decode( const char *program_ref_text = NULL; bool input_path_set = false; amduat_pel_cli_io_format_t input_format = AMDUAT_PEL_CLI_IO_RAW; - amduat_pel_cli_output_format_t format; - amduat_pel_cli_ref_format_t ref_format; + amduat_format_output_t format; + amduat_format_ref_format_t ref_format; const char *root; bool has_expect_type_tag = false; amduat_type_tag_t expect_type_tag; @@ -2251,16 +1414,10 @@ static int amduat_pel_cli_cmd_program_decode( return AMDUAT_PEL_CLI_EXIT_CODEC; } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { - if (!amduat_pel_cli_print_program_text(stdout, &program)) { - fprintf(stderr, "error: failed to format program\n"); - exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; - } - } else { - if (!amduat_pel_cli_print_program_json(stdout, &program)) { - fprintf(stderr, "error: failed to format program\n"); - exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; - } + if (!amduat_format_pel_program(stdout, &program, format)) { + fprintf(stderr, "error: failed to format program\n"); + exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; + } else if (format == AMDUAT_FORMAT_OUTPUT_JSON) { fputc('\n', stdout); } @@ -2437,8 +1594,8 @@ static int amduat_pel_cli_cmd_trace_decode( const char *trace_ref_text = NULL; bool input_path_set = false; amduat_pel_cli_io_format_t input_format = AMDUAT_PEL_CLI_IO_RAW; - amduat_pel_cli_output_format_t format; - amduat_pel_cli_ref_format_t ref_format; + amduat_format_output_t format; + amduat_format_ref_format_t ref_format; const char *root; bool has_expect_type_tag = false; amduat_type_tag_t expect_type_tag; @@ -2600,16 +1757,10 @@ static int amduat_pel_cli_cmd_trace_decode( return AMDUAT_PEL_CLI_EXIT_CODEC; } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { - if (!amduat_pel_cli_print_trace_text(stdout, &trace, ref_format)) { - fprintf(stderr, "error: failed to format trace\n"); - exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; - } - } else { - if (!amduat_pel_cli_print_trace_json(stdout, &trace, ref_format)) { - fprintf(stderr, "error: failed to format trace\n"); - exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; - } + if (!amduat_format_pel_trace(stdout, &trace, format, ref_format)) { + fprintf(stderr, "error: failed to format trace\n"); + exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; + } else if (format == AMDUAT_FORMAT_OUTPUT_JSON) { fputc('\n', stdout); } @@ -2623,8 +1774,8 @@ static int amduat_pel_cli_cmd_trace_from_result( char **argv, const amduat_pel_cli_global_opts_t *global) { const char *result_ref_text = NULL; - amduat_pel_cli_output_format_t format; - amduat_pel_cli_ref_format_t ref_format; + amduat_format_output_t format; + amduat_format_ref_format_t ref_format; const char *root; amduat_asl_store_fs_config_t cfg; amduat_asl_store_fs_t fs; @@ -2726,14 +1877,14 @@ static int amduat_pel_cli_cmd_trace_from_result( return AMDUAT_PEL_CLI_EXIT_CODEC; } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(stdout, "has_trace_ref=%s\n", result.has_trace_ref ? "true" : "false"); fprintf(stdout, "trace_ref="); if (result.has_trace_ref) { - if (!amduat_pel_cli_print_ref_text(stdout, - result.trace_ref, - ref_format)) { + if (!amduat_format_ref_write_text(stdout, + result.trace_ref, + ref_format)) { fprintf(stderr, "error: failed to encode trace ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; } @@ -2744,9 +1895,9 @@ static int amduat_pel_cli_cmd_trace_from_result( fputs(result.has_trace_ref ? "true" : "false", stdout); fputs(",\"trace_ref\":", stdout); if (result.has_trace_ref) { - if (!amduat_pel_cli_print_ref_json(stdout, - result.trace_ref, - ref_format)) { + if (!amduat_format_ref_write_json(stdout, + result.trace_ref, + ref_format)) { fprintf(stderr, "error: failed to encode trace ref\n"); exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; } @@ -2788,8 +1939,8 @@ static int amduat_pel_cli_cmd_result_decode( const char *result_ref_text = NULL; bool input_path_set = false; amduat_pel_cli_io_format_t input_format = AMDUAT_PEL_CLI_IO_RAW; - amduat_pel_cli_output_format_t format; - amduat_pel_cli_ref_format_t ref_format; + amduat_format_output_t format; + amduat_format_ref_format_t ref_format; const char *root; bool has_expect_type_tag = false; amduat_type_tag_t expect_type_tag; @@ -2951,16 +2102,10 @@ static int amduat_pel_cli_cmd_result_decode( return AMDUAT_PEL_CLI_EXIT_CODEC; } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { - if (!amduat_pel_cli_print_result_text(stdout, &result, ref_format)) { - fprintf(stderr, "error: failed to format result\n"); - exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; - } - } else { - if (!amduat_pel_cli_print_result_json(stdout, &result, ref_format)) { - fprintf(stderr, "error: failed to format result\n"); - exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; - } + if (!amduat_format_pel_result(stdout, &result, format, ref_format)) { + fprintf(stderr, "error: failed to format result\n"); + exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; + } else if (format == AMDUAT_FORMAT_OUTPUT_JSON) { fputc('\n', stdout); } @@ -2984,37 +2129,13 @@ static int amduat_pel_cli_cmd_result( return AMDUAT_PEL_CLI_EXIT_USAGE; } -static const struct { - const char *name; - uint32_t version; -} amduat_pel_cli_ops[] = { - {AMDUAT_PEL_KERNEL_OP_CONCAT_NAME, 1}, - {AMDUAT_PEL_KERNEL_OP_SLICE_NAME, 1}, - {AMDUAT_PEL_KERNEL_OP_CONST_NAME, 1}, - {AMDUAT_PEL_KERNEL_OP_HASH_ASL1_NAME, 1} -}; - -static const char *amduat_pel_cli_kernel_kind_name( - amduat_pel_kernel_op_kind_t kind) { - switch (kind) { - case AMDUAT_PEL_KERNEL_OP_CONCAT: - return "concat"; - case AMDUAT_PEL_KERNEL_OP_SLICE: - return "slice"; - case AMDUAT_PEL_KERNEL_OP_CONST: - return "const"; - case AMDUAT_PEL_KERNEL_OP_HASH_ASL1: - return "hash_asl1"; - default: - return "unknown"; - } -} - static int amduat_pel_cli_cmd_op_list( int argc, char **argv, const amduat_pel_cli_global_opts_t *global) { - amduat_pel_cli_output_format_t format; + amduat_format_output_t format; + const amduat_pel_kernel_op_desc_t *descs; + size_t descs_len = 0; size_t i; if (global == NULL) { @@ -3042,26 +2163,31 @@ static int amduat_pel_cli_cmd_op_list( } } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { - for (i = 0; i < sizeof(amduat_pel_cli_ops) / - sizeof(amduat_pel_cli_ops[0]); ++i) { - fprintf(stdout, "name=%s version=%u\n", - amduat_pel_cli_ops[i].name, - amduat_pel_cli_ops[i].version); + descs = amduat_pel_kernel_op_descs(&descs_len); + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { + for (i = 0; i < descs_len; ++i) { + const char *name = amduat_pel_kernel_op_name(descs[i].kind); + if (name == NULL) { + continue; + } + fprintf(stdout, "name=%s version=1\n", name); } } else { + bool first = true; fputs("{\"ops\":[", stdout); - for (i = 0; i < sizeof(amduat_pel_cli_ops) / - sizeof(amduat_pel_cli_ops[0]); ++i) { - if (i != 0) { + for (i = 0; i < descs_len; ++i) { + const char *name = amduat_pel_kernel_op_name(descs[i].kind); + if (name == NULL) { + continue; + } + if (!first) { fputc(',', stdout); } + first = false; fprintf(stdout, "{\"name\":"); - amduat_pel_cli_json_escape( - stdout, - (const uint8_t *)amduat_pel_cli_ops[i].name, - strlen(amduat_pel_cli_ops[i].name)); - fprintf(stdout, ",\"version\":%u}", amduat_pel_cli_ops[i].version); + amduat_format_json_escape(stdout, + amduat_octets(name, strlen(name))); + fprintf(stdout, ",\"version\":1}"); } fputs("]}\n", stdout); } @@ -3076,7 +2202,7 @@ static int amduat_pel_cli_cmd_op_describe( const char *op_text = NULL; const char *op_name = NULL; uint32_t op_version = 1; - amduat_pel_cli_output_format_t format; + amduat_format_output_t format; const amduat_pel_kernel_op_desc_t *desc; int i; @@ -3125,25 +2251,25 @@ static int amduat_pel_cli_cmd_op_describe( return AMDUAT_PEL_CLI_EXIT_NOT_FOUND; } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(stdout, "name=%s\n", op_name); fprintf(stdout, "version=%u\n", op_version); - fprintf(stdout, "kind=%s\n", amduat_pel_cli_kernel_kind_name(desc->kind)); + fprintf(stdout, "kind=%s\n", + amduat_format_pel_kernel_kind_name(desc->kind)); fprintf(stdout, "kernel_op_code=0x%04x\n", desc->kernel_op_code); fprintf(stdout, "min_inputs=%zu\n", desc->min_inputs); fprintf(stdout, "max_inputs=%zu\n", desc->max_inputs); fprintf(stdout, "outputs_len=%zu\n", desc->outputs_len); } else { fputs("{\"name\":", stdout); - amduat_pel_cli_json_escape(stdout, - (const uint8_t *)op_name, - strlen(op_name)); + amduat_format_json_escape( + stdout, amduat_octets(op_name, strlen(op_name))); fprintf(stdout, ",\"version\":%u", op_version); fputs(",\"kind\":", stdout); - amduat_pel_cli_json_escape( + amduat_format_json_escape( stdout, - (const uint8_t *)amduat_pel_cli_kernel_kind_name(desc->kind), - strlen(amduat_pel_cli_kernel_kind_name(desc->kind))); + amduat_octets(amduat_format_pel_kernel_kind_name(desc->kind), + strlen(amduat_format_pel_kernel_kind_name(desc->kind)))); fprintf(stdout, ",\"kernel_op_code\":%u", desc->kernel_op_code); fprintf(stdout, ",\"min_inputs\":%zu", desc->min_inputs); fprintf(stdout, ",\"max_inputs\":%zu", desc->max_inputs); @@ -3162,7 +2288,7 @@ static int amduat_pel_cli_cmd_op_params_decode( const char *op_name = NULL; uint32_t op_version = 1; const char *input_path = NULL; - amduat_pel_cli_output_format_t format; + amduat_format_output_t format; const amduat_pel_kernel_op_desc_t *desc; amduat_pel_kernel_params_t params; uint8_t *bytes = NULL; @@ -3243,10 +2369,11 @@ static int amduat_pel_cli_cmd_op_params_decode( return AMDUAT_PEL_CLI_EXIT_CODEC; } - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(stdout, "op=%s\n", op_name); fprintf(stdout, "version=%u\n", op_version); - fprintf(stdout, "kind=%s\n", amduat_pel_cli_kernel_kind_name(params.kind)); + fprintf(stdout, "kind=%s\n", + amduat_format_pel_kernel_kind_name(params.kind)); switch (params.kind) { case AMDUAT_PEL_KERNEL_OP_CONCAT: fprintf(stdout, "params=unit\n"); @@ -3258,8 +2385,10 @@ static int amduat_pel_cli_cmd_op_params_decode( (uint64_t)params.value.slice.length); break; case AMDUAT_PEL_KERNEL_OP_CONST: { - char *hex = amduat_pel_cli_hex_encode(params.value.konst.bytes); - if (hex == NULL) { + char *hex = NULL; + if (!amduat_hex_encode_alloc(params.value.konst.bytes.data, + params.value.konst.bytes.len, + &hex)) { exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; break; } @@ -3288,15 +2417,15 @@ static int amduat_pel_cli_cmd_op_params_decode( } } else { fputs("{\"op\":", stdout); - amduat_pel_cli_json_escape(stdout, - (const uint8_t *)op_name, - strlen(op_name)); + amduat_format_json_escape( + stdout, amduat_octets(op_name, strlen(op_name))); fprintf(stdout, ",\"version\":%u", op_version); fputs(",\"kind\":", stdout); - amduat_pel_cli_json_escape( + amduat_format_json_escape( stdout, - (const uint8_t *)amduat_pel_cli_kernel_kind_name(params.kind), - strlen(amduat_pel_cli_kernel_kind_name(params.kind))); + amduat_octets(amduat_format_pel_kernel_kind_name(params.kind), + strlen(amduat_format_pel_kernel_kind_name( + params.kind)))); switch (params.kind) { case AMDUAT_PEL_KERNEL_OP_CONCAT: fputs(",\"params\":null", stdout); @@ -3308,8 +2437,10 @@ static int amduat_pel_cli_cmd_op_params_decode( (uint64_t)params.value.slice.length); break; case AMDUAT_PEL_KERNEL_OP_CONST: { - char *hex = amduat_pel_cli_hex_encode(params.value.konst.bytes); - if (hex == NULL) { + char *hex = NULL; + if (!amduat_hex_encode_alloc(params.value.konst.bytes.data, + params.value.konst.bytes.len, + &hex)) { exit_code = AMDUAT_PEL_CLI_EXIT_CODEC; break; } @@ -3321,9 +2452,8 @@ static int amduat_pel_cli_cmd_op_params_decode( fputs(",\"type_tag\":null", stdout); } fputs(",\"bytes_hex\":", stdout); - amduat_pel_cli_json_escape(stdout, - (const uint8_t *)hex, - strlen(hex)); + amduat_format_json_escape(stdout, + amduat_octets(hex, strlen(hex))); free(hex); break; } @@ -3334,10 +2464,9 @@ static int amduat_pel_cli_cmd_op_params_decode( (unsigned int)params.value.hash.hash_id); fputs(",\"hash_name\":", stdout); if (desc_hash != NULL && desc_hash->name != NULL) { - amduat_pel_cli_json_escape( + amduat_format_json_escape( stdout, - (const uint8_t *)desc_hash->name, - strlen(desc_hash->name)); + amduat_octets(desc_hash->name, strlen(desc_hash->name))); } else { fputs("null", stdout); } @@ -3379,8 +2508,8 @@ static int amduat_pel_cli_cmd_scheme_show( int argc, char **argv, const amduat_pel_cli_global_opts_t *global) { - amduat_pel_cli_output_format_t format; - amduat_pel_cli_ref_format_t ref_format; + amduat_format_output_t format; + amduat_format_ref_format_t ref_format; amduat_reference_t scheme_ref; int i; @@ -3421,9 +2550,9 @@ static int amduat_pel_cli_cmd_scheme_show( scheme_ref = amduat_pel_program_dag_scheme_ref(); - if (format == AMDUAT_PEL_CLI_FORMAT_TEXT) { + if (format == AMDUAT_FORMAT_OUTPUT_TEXT) { fprintf(stdout, "scheme_ref="); - if (!amduat_pel_cli_print_ref_text(stdout, scheme_ref, ref_format)) { + if (!amduat_format_ref_write_text(stdout, scheme_ref, ref_format)) { fprintf(stderr, "error: failed to encode scheme ref\n"); return AMDUAT_PEL_CLI_EXIT_CODEC; } @@ -3442,7 +2571,7 @@ static int amduat_pel_cli_cmd_scheme_show( AMDUAT_PEL_ENC_EXECUTION_RESULT_V1); } else { fputs("{\"scheme_ref\":", stdout); - if (!amduat_pel_cli_print_ref_json(stdout, scheme_ref, ref_format)) { + if (!amduat_format_ref_write_json(stdout, scheme_ref, ref_format)) { fprintf(stderr, "error: failed to encode scheme ref\n"); return AMDUAT_PEL_CLI_EXIT_CODEC; } @@ -3464,7 +2593,7 @@ static int amduat_pel_cli_cmd_scheme_show( } static int amduat_pel_cli_cmd_scheme_dag_ref(int argc, char **argv) { - amduat_pel_cli_ref_format_t fmt = AMDUAT_PEL_CLI_REF_HEX; + amduat_format_ref_format_t fmt = AMDUAT_FORMAT_REF_HEX; amduat_reference_t scheme_ref; int i; @@ -3489,7 +2618,7 @@ static int amduat_pel_cli_cmd_scheme_dag_ref(int argc, char **argv) { } scheme_ref = amduat_pel_program_dag_scheme_ref(); - if (fmt == AMDUAT_PEL_CLI_REF_HEX) { + if (fmt == AMDUAT_FORMAT_REF_HEX) { char *text = NULL; if (!amduat_asl_ref_encode_hex(scheme_ref, &text)) { fprintf(stderr, "error: failed to encode scheme ref\n"); @@ -3547,8 +2676,8 @@ int main(int argc, char **argv) { memset(&global, 0, sizeof(global)); global.root = AMDUAT_PEL_CLI_DEFAULT_ROOT; - global.ref_format = AMDUAT_PEL_CLI_REF_HEX; - global.format = AMDUAT_PEL_CLI_FORMAT_TEXT; + global.ref_format = AMDUAT_FORMAT_REF_HEX; + global.format = AMDUAT_FORMAT_OUTPUT_TEXT; global.quiet = false; for (i = 1; i < argc; ++i) {