785 lines
25 KiB
C
785 lines
25 KiB
C
#include "amduat/format/pel.h"
|
|
|
|
#include "amduat/format/json.h"
|
|
#include "amduat/format/ref.h"
|
|
#include "amduat/util/hex.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
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);
|
|
}
|