wangdequan/linuxcncWebWASM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2b1e249baf58bc7e11a0971c63f1c0dd5f12eb77
linuxcncWebWASM/wasm-core/src/sim_program.c

507 lines
25 KiB
C
Raw Blame History

#include "sim_program.h"
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static uint64_t fnv1a64(const unsigned char *bytes, size_t length) {
uint64_t hash = UINT64_C(1469598103934665603);
size_t index;
for (index = 0; index < length; ++index) { hash ^= bytes[index]; hash *= UINT64_C(1099511628211); }
return hash;
}
static int control_line(const char *line) {
const char *cursor = line;
while (*cursor != '\0' && isspace((unsigned char)*cursor)) ++cursor;
if (*cursor == 'O' || *cursor == 'o') return 1;
if ((cursor[0] == 'M' || cursor[0] == 'm') && (cursor[1] == '8' || cursor[1] == '9')) return 1;
if ((cursor[0] == 'M' || cursor[0] == 'm') && (cursor[1] == '9' || cursor[1] == '8')) return 1;
return 0;
}
static uint32_t line_length(const char *line, uint32_t maximum) {
uint32_t length = 0;
while (length < maximum && line[length] != '\0' && line[length] != '\n' && line[length] != '\r') ++length;
return length;
}
static int span_equal(const char *value, size_t length, const char *expected) {
size_t index;
if (strlen(expected) != length) return 0;
for (index = 0; index < length; ++index)
if (tolower((unsigned char)value[index]) != tolower((unsigned char)expected[index])) return 0;
return 1;
}
static int parse_oword(const char *line, uint32_t length, char *name, size_t name_capacity,
const char **verb, size_t *verb_length, const char **arguments) {
const char *cursor = line;
const char *end = line + length;
size_t name_length = 0;
while (cursor < end && isspace((unsigned char)*cursor)) ++cursor;
if (cursor >= end || tolower((unsigned char)*cursor++) != 'o' || cursor >= end || *cursor++ != '<') return 0;
while (cursor < end && *cursor != '>') {
if (name_length + 1u >= name_capacity) return 0;
name[name_length++] = (char)tolower((unsigned char)*cursor++);
}
if (cursor >= end || *cursor++ != '>' || name_length == 0) return 0;
name[name_length] = '\0';
while (cursor < end && isspace((unsigned char)*cursor)) ++cursor;
*verb = cursor;
while (cursor < end && isalpha((unsigned char)*cursor)) ++cursor;
*verb_length = (size_t)(cursor - *verb);
while (cursor < end && isspace((unsigned char)*cursor)) ++cursor;
*arguments = cursor;
return *verb_length > 0;
}
int32_t sim_program_requires_subroutines(const char *source, uint32_t length) {
uint32_t offset = 0;
if (source == NULL || length == 0) return SIM_PROGRAM_ERR_ARGUMENT;
if (length > SIM_PROGRAM_MAX_SOURCE_BYTES) return SIM_PROGRAM_ERR_RANGE;
while (offset < length) {
uint32_t available = length - offset;
uint32_t line_size = line_length(source + offset, available);
char name[SIM_PROGRAM_SUBROUTINE_NAME_CAPACITY] = {0};
const char *verb = NULL, *arguments = NULL;
size_t verb_length = 0;
if (parse_oword(source + offset, line_size, name, sizeof(name), &verb, &verb_length, &arguments) && span_equal(verb, verb_length, "call")) return 1;
offset += line_size;
while (offset < length && (source[offset] == '\n' || source[offset] == '\r')) ++offset;
}
return 0;
}
static int ensure_source_capacity(sim_program *program, uint32_t required) {
uint32_t capacity;
char *source;
if (required <= program->source_capacity) return SIM_PROGRAM_OK;
capacity = program->source_capacity == 0 ? SIM_PROGRAM_SOURCE_CAPACITY : program->source_capacity;
while (capacity < required) {
if (capacity >= SIM_PROGRAM_MAX_SOURCE_BYTES / 2u) { capacity = SIM_PROGRAM_MAX_SOURCE_BYTES; break; }
capacity *= 2u;
}
if (capacity < required || capacity > SIM_PROGRAM_MAX_SOURCE_BYTES) return SIM_PROGRAM_ERR_RANGE;
source = (char *)realloc(program->source, capacity);
if (source == NULL) return SIM_PROGRAM_ERR_RANGE;
program->source = source;
program->source_capacity = capacity;
return SIM_PROGRAM_OK;
}
static int ensure_line_capacity(sim_program *program, uint32_t required) {
uint32_t capacity;
uint32_t *offsets;
if (required <= program->line_capacity) return SIM_PROGRAM_OK;
capacity = program->line_capacity == 0 ? SIM_PROGRAM_LINE_CAPACITY + 1u : program->line_capacity;
while (capacity < required) {
if (capacity >= SIM_PROGRAM_MAX_LINE_COUNT / 2u) { capacity = SIM_PROGRAM_MAX_LINE_COUNT + 1u; break; }
capacity *= 2u;
}
if (capacity > SIM_PROGRAM_MAX_LINE_COUNT + 1u) return SIM_PROGRAM_ERR_RANGE;
offsets = (uint32_t *)realloc(program->line_offsets, (size_t)capacity * sizeof(*offsets));
if (offsets == NULL) return SIM_PROGRAM_ERR_RANGE;
program->line_offsets = offsets;
program->line_capacity = capacity;
return SIM_PROGRAM_OK;
}
static int reindex_source(sim_program *program) {
uint32_t index;
if (ensure_line_capacity(program, 2u) != SIM_PROGRAM_OK) return SIM_PROGRAM_ERR_RANGE;
program->line_count = program->source_length == 0 ? 0 : 1;
program->line_offsets[0] = 0;
for (index = 0; index < program->source_length; ++index) if (program->source[index] == '\n' && index + 1u < program->source_length) {
if (program->line_count >= SIM_PROGRAM_MAX_LINE_COUNT || ensure_line_capacity(program, program->line_count + 2u) != SIM_PROGRAM_OK) return SIM_PROGRAM_ERR_RANGE;
program->line_offsets[program->line_count++] = index + 1u;
}
program->line_offsets[program->line_count] = program->source_length;
return SIM_PROGRAM_OK;
}
static int append_source(sim_program *program, const char *source, uint32_t length) {
uint32_t separator;
uint64_t required;
if (source == NULL || length == 0) return SIM_PROGRAM_ERR_ARGUMENT;
separator = program->source_length > 0 && program->source[program->source_length - 1u] != '\n' ? 1u : 0u;
required = (uint64_t)program->source_length + separator + length + 1u;
if (required > SIM_PROGRAM_MAX_SOURCE_BYTES + 1ull || ensure_source_capacity(program, (uint32_t)required) != SIM_PROGRAM_OK) return SIM_PROGRAM_ERR_RANGE;
if (separator) program->source[program->source_length++] = '\n';
memcpy(program->source + program->source_length, source, length);
program->source_length += length;
program->source[program->source_length] = '\0';
return reindex_source(program);
}
static int scan_subroutines(sim_program *program) {
uint32_t line;
program->subroutine_count = 0;
for (line = program->main_line_count; line < program->line_count; ++line) {
const char *start = program->source + program->line_offsets[line];
uint32_t maximum = program->line_offsets[line + 1u] - program->line_offsets[line];
uint32_t length = line_length(start, maximum);
char name[SIM_PROGRAM_SUBROUTINE_NAME_CAPACITY] = {0};
const char *verb = NULL, *arguments = NULL;
size_t verb_length = 0;
uint32_t end_line;
if (!parse_oword(start, length, name, sizeof(name), &verb, &verb_length, &arguments) || !span_equal(verb, verb_length, "sub")) continue;
for (end_line = line + 1u; end_line < program->line_count; ++end_line) {
const char *end_start = program->source + program->line_offsets[end_line];
uint32_t end_maximum = program->line_offsets[end_line + 1u] - program->line_offsets[end_line];
uint32_t end_length = line_length(end_start, end_maximum);
char end_name[SIM_PROGRAM_SUBROUTINE_NAME_CAPACITY] = {0};
const char *end_verb = NULL, *end_arguments = NULL;
size_t end_verb_length = 0;
if (parse_oword(end_start, end_length, end_name, sizeof(end_name), &end_verb, &end_verb_length, &end_arguments) && strcmp(name, end_name) == 0 && span_equal(end_verb, end_verb_length, "endsub")) break;
}
if (end_line >= program->line_count || program->subroutine_count >= SIM_PROGRAM_SUBROUTINE_CAPACITY) return SIM_PROGRAM_ERR_CONTROL;
strncpy(program->subroutines[program->subroutine_count].name, name, SIM_PROGRAM_SUBROUTINE_NAME_CAPACITY - 1u);
program->subroutines[program->subroutine_count].body_line = line + 1u;
program->subroutines[program->subroutine_count].end_line = end_line;
program->subroutine_count += 1u;
line = end_line;
}
return SIM_PROGRAM_OK;
}
static const sim_program_subroutine *find_subroutine(const sim_program *program, const char *name) {
uint32_t index;
for (index = 0; index < program->subroutine_count; ++index)
if (strcmp(program->subroutines[index].name, name) == 0) return &program->subroutines[index];
return NULL;
}
static int evaluate_call_arguments(sim_program *program, const char *cursor, const char *end,
double *values, uint32_t *count) {
uint32_t item = 0;
while (cursor < end) {
const char *start;
const char *finish;
int depth = 0;
char assignment[512];
int written;
while (cursor < end && isspace((unsigned char)*cursor)) ++cursor;
if (cursor >= end || *cursor == ';' || *cursor == '(') break;
if (item >= SIM_PROGRAM_CALL_PARAMETER_CAPACITY) return SIM_PROGRAM_ERR_CONTROL;
start = cursor;
if (*cursor == '[') {
do {
if (*cursor == '[') depth += 1;
else if (*cursor == ']') depth -= 1;
++cursor;
} while (cursor < end && depth > 0);
if (depth != 0) return SIM_PROGRAM_ERR_CONTROL;
finish = cursor;
} else {
while (cursor < end && !isspace((unsigned char)*cursor) && *cursor != ';' && *cursor != '(') ++cursor;
finish = cursor;
}
written = snprintf(assignment, sizeof(assignment), "#5000=%.*s", (int)(finish - start), start);
if (written <= 0 || (size_t)written >= sizeof(assignment) || sim_interpreter_execute(&program->interpreter, assignment, (uint32_t)written) != SIM_INTERP_OK || sim_interpreter_parameter_get(&program->interpreter, 5000, &values[item]) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
item += 1u;
}
*count = item;
return SIM_PROGRAM_OK;
}
static int begin_call(sim_program *program, const char *name, const char *arguments, const char *end) {
const sim_program_subroutine *subroutine = find_subroutine(program, name);
sim_program_call_frame *frame;
double values[SIM_PROGRAM_CALL_PARAMETER_CAPACITY] = {0};
uint32_t count = 0, index;
int result;
if (subroutine == NULL || program->call_depth >= SIM_PROGRAM_CALL_DEPTH) return SIM_PROGRAM_ERR_CONTROL;
result = evaluate_call_arguments(program, arguments, end, values, &count);
if (result != SIM_PROGRAM_OK) return result;
frame = &program->call_stack[program->call_depth++];
frame->return_line = program->current_line;
for (index = 0; index < SIM_PROGRAM_CALL_PARAMETER_CAPACITY; ++index) {
if (sim_interpreter_parameter_get(&program->interpreter, index + 1u, &frame->parameters[index]) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
if (sim_interpreter_parameter_set(&program->interpreter, index + 1u, index < count ? values[index] : 0.0) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
}
program->current_line = subroutine->body_line;
return SIM_PROGRAM_OK;
}
static int end_call(sim_program *program) {
sim_program_call_frame *frame;
uint32_t index;
if (program->call_depth == 0) return SIM_PROGRAM_ERR_CONTROL;
frame = &program->call_stack[--program->call_depth];
for (index = 0; index < SIM_PROGRAM_CALL_PARAMETER_CAPACITY; ++index)
if (sim_interpreter_parameter_set(&program->interpreter, index + 1u, frame->parameters[index]) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
program->current_line = frame->return_line;
return SIM_PROGRAM_OK;
}
static int switch_mcode(const char *block, uint32_t length) {
const char *cursor = block;
const char *end = block + length;
while (cursor < end) {
if (*cursor == ';') break;
if (*cursor == '(') { while (cursor < end && *cursor++ != ')') {} continue; }
if (toupper((unsigned char)*cursor) == 'M') {
char *number_end = NULL;
long code = strtol(cursor + 1, &number_end, 10);
if (number_end != cursor + 1 && (code == 428 || code == 429 || code == 430)) return (int)code;
}
++cursor;
}
return 0;
}
static int parse_motion_control(sim_program *program, const char *block, uint32_t length) {
const char *cursor = block;
const char *end = block + length;
int active = 0;
double path = 0.0;
double naive = 0.0;
while (cursor < end) {
char letter;
char *number_end;
double value;
while (cursor < end && isspace((unsigned char)*cursor)) ++cursor;
if (cursor >= end || *cursor == ';') break;
if (*cursor == '(') { while (cursor < end && *cursor++ != ')') {} continue; }
if (!isalpha((unsigned char)*cursor)) { ++cursor; continue; }
letter = (char)toupper((unsigned char)*cursor++);
value = strtod(cursor, &number_end);
if (number_end == cursor) continue;
cursor = number_end;
if (letter == 'G') {
if (fabs(value - 61.0) <= 1e-12) active = SIM_PROGRAM_MOTION_EXACT_PATH;
else if (fabs(value - 61.1) <= 1e-12) active = SIM_PROGRAM_MOTION_EXACT_STOP;
else if (fabs(value - 64.0) <= 1e-12) active = SIM_PROGRAM_MOTION_CONTINUOUS;
else active = 0;
if (active != 0 || fabs(value - 64.0) <= 1e-12) {
program->motion_control_mode = active;
path = 0.0;
naive = 0.0;
}
} else if (active == SIM_PROGRAM_MOTION_CONTINUOUS && (letter == 'P' || letter == 'Q')) {
if (!isfinite(value) || value < 0.0) return SIM_PROGRAM_ERR_RANGE;
if (letter == 'P') path = value;
else naive = value;
program->path_tolerance = path;
program->naive_cam_tolerance = naive;
}
}
return SIM_PROGRAM_OK;
}
static void reset_runtime(sim_program *program) {
sim_interpreter_reset(&program->interpreter);
program->source_length = 0;
program->line_count = 0;
program->main_line_count = 0;
program->current_line = 0;
program->status = SIM_PROGRAM_IDLE;
program->last_error = 0;
program->error_line = 0;
program->has_motion = 0;
program->subroutine_count = 0;
program->call_depth = 0;
program->has_control = 0;
program->control_code = 0;
program->rapid_velocity = 35.0;
program->motion_control_mode = SIM_PROGRAM_MOTION_CONTINUOUS;
program->path_tolerance = 0.0;
program->naive_cam_tolerance = 0.0;
memset(&program->motion, 0, sizeof(program->motion));
memset(program->subroutines, 0, sizeof(program->subroutines));
memset(program->call_stack, 0, sizeof(program->call_stack));
}
uint32_t sim_program_size(void) { return (uint32_t)sizeof(sim_program); }
int32_t sim_program_init(sim_program *program) {
if (program == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
memset(program, 0, sizeof(*program));
if (sim_interpreter_init(&program->interpreter) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
program->status = SIM_PROGRAM_IDLE;
return SIM_PROGRAM_OK;
}
int32_t sim_program_reset(sim_program *program) {
if (program == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
if (sim_interpreter_reset(&program->interpreter) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
free(program->source);
free(program->line_offsets);
program->source = NULL;
program->line_offsets = NULL;
program->source_capacity = 0;
program->line_capacity = 0;
reset_runtime(program);
return SIM_PROGRAM_OK;
}
void sim_program_destroy(sim_program *program) {
if (program == NULL) return;
(void)sim_program_reset(program);
}
int32_t sim_program_load(sim_program *program, const char *source, uint32_t length) {
if (program == NULL || source == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
if (length == 0 || length > SIM_PROGRAM_MAX_SOURCE_BYTES) return SIM_PROGRAM_ERR_RANGE;
if (sim_program_reset(program) != SIM_PROGRAM_OK) return SIM_PROGRAM_ERR_INTERPRETER;
if (append_source(program, source, length) != SIM_PROGRAM_OK) return SIM_PROGRAM_ERR_RANGE;
program->main_line_count = program->line_count;
program->status = SIM_PROGRAM_LOADED;
return SIM_PROGRAM_OK;
}
int32_t sim_program_add_subroutine(sim_program *program, const char *source, uint32_t length) {
int result;
if (program == NULL || source == NULL || program->status != SIM_PROGRAM_LOADED) return SIM_PROGRAM_ERR_STATE;
result = append_source(program, source, length);
if (result != SIM_PROGRAM_OK) return result;
return scan_subroutines(program);
}
int32_t sim_program_set_rapid_velocity(sim_program *program, double velocity) {
if (program == NULL || !isfinite(velocity) || velocity <= 0.0 || velocity > 1e9) return SIM_PROGRAM_ERR_RANGE;
program->rapid_velocity = velocity;
return SIM_PROGRAM_OK;
}
int32_t sim_program_start(sim_program *program) {
if (program == NULL || program->status == SIM_PROGRAM_IDLE) return SIM_PROGRAM_ERR_STATE;
if (program->status == SIM_PROGRAM_COMPLETED || program->status == SIM_PROGRAM_ABORTED) return SIM_PROGRAM_ERR_STATE;
program->status = SIM_PROGRAM_RUNNING;
return SIM_PROGRAM_OK;
}
int32_t sim_program_pause(sim_program *program) {
if (program == NULL || program->status != SIM_PROGRAM_RUNNING) return SIM_PROGRAM_ERR_STATE;
program->status = SIM_PROGRAM_PAUSED;
return SIM_PROGRAM_OK;
}
int32_t sim_program_resume(sim_program *program) {
if (program == NULL || program->status != SIM_PROGRAM_PAUSED) return SIM_PROGRAM_ERR_STATE;
program->status = SIM_PROGRAM_RUNNING;
return SIM_PROGRAM_OK;
}
int32_t sim_program_abort(sim_program *program) {
if (program == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
program->status = SIM_PROGRAM_ABORTED;
program->has_motion = 0;
return SIM_PROGRAM_OK;
}
int32_t sim_program_execute_block(sim_program *program, const char *block, uint32_t length) {
sim_posemath_segment segment;
int result;
if (program == NULL || block == NULL || length == 0) return SIM_PROGRAM_ERR_ARGUMENT;
if (control_line(block)) return SIM_PROGRAM_ERR_CONTROL;
result = parse_motion_control(program, block, length);
if (result != SIM_PROGRAM_OK) return result;
program->has_control = 0;
program->control_code = switch_mcode(block, length);
if (program->control_code != 0) program->has_control = 1;
result = sim_interpreter_execute(&program->interpreter, block, length);
if (result != SIM_INTERP_OK) { program->last_error = result; return SIM_PROGRAM_ERR_INTERPRETER; }
memset(&segment, 0, sizeof(segment));
if (sim_interpreter_read_motion(&program->interpreter, &segment) == SIM_INTERP_OK && segment.motion_type != 0) {
if (program->interpreter.state.motion_mode == 0) segment.velocity = program->rapid_velocity;
program->motion = segment; program->has_motion = 1;
} else program->has_motion = 0;
return SIM_PROGRAM_OK;
}
int32_t sim_program_step(sim_program *program) {
uint32_t line;
if (program == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
if (program->status == SIM_PROGRAM_PAUSED) return SIM_PROGRAM_ERR_STATE;
if (program->status != SIM_PROGRAM_RUNNING) return SIM_PROGRAM_ERR_STATE;
program->has_motion = 0;
program->has_control = 0;
program->control_code = 0;
while (program->current_line < program->line_count) {
const char *line_start = program->source + program->line_offsets[program->current_line];
uint32_t maximum = program->line_offsets[program->current_line + 1u] - program->line_offsets[program->current_line];
uint32_t length = line_length(line_start, maximum);
program->current_line += 1;
line = program->current_line;
while (length > 0 && isspace((unsigned char)line_start[length - 1u])) --length;
if (length == 0 || line_start[0] == ';') continue;
{
char name[SIM_PROGRAM_SUBROUTINE_NAME_CAPACITY] = {0};
const char *verb = NULL, *arguments = NULL;
size_t verb_length = 0;
if (parse_oword(line_start, length, name, sizeof(name), &verb, &verb_length, &arguments)) {
int control_result;
if (span_equal(verb, verb_length, "call")) control_result = begin_call(program, name, arguments, line_start + length);
else if (span_equal(verb, verb_length, "endsub")) control_result = end_call(program);
else if (span_equal(verb, verb_length, "sub")) {
const sim_program_subroutine *declared = find_subroutine(program, name);
program->current_line = declared ? declared->end_line + 1u : program->line_count;
continue;
}
else control_result = SIM_PROGRAM_ERR_CONTROL;
if (control_result != SIM_PROGRAM_OK) { program->last_error = control_result; program->error_line = line; program->status = SIM_PROGRAM_ERROR; return control_result; }
return SIM_PROGRAM_OK;
}
}
if (control_line(line_start)) { program->last_error = SIM_PROGRAM_ERR_CONTROL; program->error_line = line; program->status = SIM_PROGRAM_ERROR; return SIM_PROGRAM_ERR_CONTROL; }
if (sim_program_execute_block(program, line_start, length) != SIM_PROGRAM_OK) { program->error_line = line; program->status = SIM_PROGRAM_ERROR; return SIM_PROGRAM_ERR_INTERPRETER; }
if (program->interpreter.state.program_end || (program->call_depth == 0 && program->current_line >= program->main_line_count)) program->status = SIM_PROGRAM_COMPLETED;
return SIM_PROGRAM_OK;
}
program->status = SIM_PROGRAM_COMPLETED;
return SIM_PROGRAM_OK;
}
int32_t sim_program_seek(sim_program *program, uint32_t line) {
if (program == NULL || line > program->line_count) return SIM_PROGRAM_ERR_RANGE;
if (sim_interpreter_reset(&program->interpreter) != SIM_INTERP_OK) return SIM_PROGRAM_ERR_INTERPRETER;
program->current_line = 0; program->status = SIM_PROGRAM_PAUSED; program->has_motion = 0;
while (program->current_line < line) {
int result = sim_program_step(program);
if (result != SIM_PROGRAM_OK && result != SIM_PROGRAM_ERR_STATE) return result;
if (program->status == SIM_PROGRAM_COMPLETED) break;
program->status = SIM_PROGRAM_PAUSED;
if (program->current_line >= line) break;
program->status = SIM_PROGRAM_RUNNING;
}
program->status = SIM_PROGRAM_PAUSED;
return SIM_PROGRAM_OK;
}
int32_t sim_program_read_motion(const sim_program *program, sim_posemath_segment *segment) {
if (program == NULL || segment == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
if (!program->has_motion) return SIM_PROGRAM_ERR_STATE;
*segment = program->motion;
return SIM_PROGRAM_OK;
}
int32_t sim_program_clear_motion(sim_program *program) {
if (program == NULL) return SIM_PROGRAM_ERR_ARGUMENT;
program->has_motion = 0;
memset(&program->motion, 0, sizeof(program->motion));
return SIM_PROGRAM_OK;
}
uint32_t sim_program_canonical(const sim_program *program, char *output, uint32_t capacity) {
char discard[1];
char *destination = output == NULL ? discard : output;
uint32_t destination_capacity = output == NULL ? 1 : capacity;
int written;
if (program == NULL) return 0;
written = snprintf(destination, destination_capacity,
"{\"call_depth\":%u,\"control_code\":%d,\"current_line\":%u,\"error_line\":%u,\"feed\":%.17g,\"has_control\":%u,\"has_motion\":%u,\"last_error\":%d,\"line_count\":%u,\"main_line_count\":%u,\"motion_control_mode\":%d,\"path_tolerance\":%.17g,\"naive_cam_tolerance\":%.17g,\"motion_mode\":%d,\"plane\":%d,\"rapid_velocity\":%.17g,\"schema\":\"sim_program.v1\",\"speed\":%.17g,\"spindle_mode\":%d,\"status\":%u,\"subroutine_count\":%u,\"source_length\":%u,\"units\":%d,\"distance_mode\":%d,\"interpreter_state_hash\":\"%llu\"}",
program->call_depth, program->control_code, program->current_line, program->error_line, program->interpreter.state.feed, program->has_control, program->has_motion, program->last_error, program->line_count, program->main_line_count, program->motion_control_mode, program->path_tolerance, program->naive_cam_tolerance, program->interpreter.state.motion_mode, program->interpreter.state.plane, program->rapid_velocity, program->interpreter.state.speed, program->interpreter.state.spindle_mode, program->status, program->subroutine_count, program->source_length, program->interpreter.state.units, program->interpreter.state.distance_mode,
(unsigned long long)sim_interpreter_state_hash(&program->interpreter));
return written < 0 ? 0 : (uint32_t)written + 1u;
}
uint64_t sim_program_state_hash(const sim_program *program) {
char canonical[SIM_PROGRAM_CANONICAL_CAPACITY];
uint32_t length = sim_program_canonical(program, canonical, sizeof(canonical));
return length == 0 ? 0 : fnv1a64((const unsigned char *)canonical, length - 1u);
}
Reference in New Issue View Git Blame Copy Permalink