ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
public_api.c
Go to the documentation of this file.
1
13
15#include <options/registry/core.h>
17#include <options/actions.h>
18#include <libflags/config/keys.h>
19#include <libflags/flags.h>
20#include <libflags/builder.h>
21#include <string.h>
22#include <stdlib.h>
23#include <errno.h>
24
25static bool registry_flags_validate(const flags_context_t *context, const char *name, const flags_value_t *value, char *error, size_t error_size, void *user_data) {
26 (void)context;
27 (void)name;
28 (void)error;
29 (void)error_size;
30 const registry_entry_t *entry = user_data;
31 if (!entry || strcmp(entry->long_name, "snapshot-delay") != 0 || !value)
32 return true;
33 return value->number >= 0.0;
34}
35
36static void registry_flags_change(flags_context_t *context, const char *name, const flags_value_t *old_value, const flags_value_t *new_value, void *user_data) {
37 (void)name;
38 (void)old_value;
39 const registry_entry_t *entry = user_data;
40 if (!context || !entry || !new_value)
41 return;
42 if (entry->type == OPTION_TYPE_ACTION) {
44 if (action)
45 action();
46 return;
47 }
48 if (!entry->parse_fn)
49 return;
50 void *storage = flags_context_storage(context);
51 if (!storage)
52 return;
53 char *error = NULL;
54 entry->parse_fn(new_value->string, (char *)storage + entry->offset, &error);
55 free(error);
56 if (strcmp(entry->long_name, "palette-chars") == 0) {
57 options_t *options = storage;
58 options->palette_custom_set = true;
60 }
61}
62
63static bool registry_flags_parse(flags_context_t *context, const char *text, flags_value_t *value, void *user_data) {
64 const registry_entry_t *entry = user_data;
65 if (!context || !entry || !text || !value || !entry->parse_fn)
66 return false;
67 void *storage = flags_context_storage(context);
68 if (!storage)
69 return false;
70 char *error = NULL;
71 bool parsed = entry->parse_fn(text, (char *)storage + entry->offset, &error);
72 free(error);
73 if (!parsed)
74 return false;
75 if (strcmp(entry->long_name, "palette-chars") == 0) {
76 options_t *options = storage;
77 options->palette_custom_set = true;
79 }
80 value->string = text;
81 return true;
82}
83
85 if (!builder)
86 return SET_ERRNO(ERROR_INVALID_PARAM, "Flags builder is NULL");
88 for (size_t i = 0; i < g_registry_size; ++i) {
89 const registry_entry_t *entry = &g_options_registry[i];
90 if (!entry->long_name || (entry->mode_bitmask != OPTION_MODE_NONE && !(entry->mode_bitmask & mode_mask) && !(entry->mode_bitmask & OPTION_MODE_BINARY)))
91 continue;
92 /* These binary commands are handled by ascii-chat's command dispatcher,
93 * not stored as values in options_t. */
94 if (entry->type == OPTION_TYPE_STRING && entry->default_value_size == 0 && entry->offset == 0)
95 continue;
96 flags_value_type_t type;
97 flags_option_behavior_t behavior = FLAGS_BEHAVIOR_VALUE;
98 switch (entry->type) {
100 type = FLAGS_TYPE_BOOL;
101 break;
102 case OPTION_TYPE_INT:
103 type = FLAGS_TYPE_INT64;
104 break;
106 type = FLAGS_TYPE_DOUBLE;
107 break;
109 type = FLAGS_TYPE_STRING;
110 break;
112 type = FLAGS_TYPE_CUSTOM;
113 behavior = FLAGS_BEHAVIOR_CALLBACK;
114 break;
116 type = FLAGS_TYPE_CUSTOM;
117 behavior = FLAGS_BEHAVIOR_ACTION;
118 break;
119 default:
120 continue;
121 }
122 flags_option_spec_t option = {.name = entry->long_name,
123 .short_name = entry->short_name,
124 .description = entry->help_text,
125 .group = entry->group,
126 .required = entry->required,
127 .metavar = entry->arg_placeholder,
128 .environment_name = entry->env_var_name,
129 .type = type,
130 .behavior = behavior,
131 .default_operation = entry->type == OPTION_TYPE_BOOL ? FLAGS_VALUE_TOGGLE : FLAGS_VALUE_ASSIGN,
132 .argument_requirement = entry->type == OPTION_TYPE_BOOL || entry->type == OPTION_TYPE_ACTION ? FLAGS_ARGUMENT_NONE
133 : entry->optional_arg ? FLAGS_ARGUMENT_OPTIONAL
134 : FLAGS_ARGUMENT_REQUIRED,
135 .storage_offset = entry->offset,
136 .storage_size = entry->type == OPTION_TYPE_STRING
137 ? (entry->owns_memory ? sizeof(char *) : (entry->default_value_size ? entry->default_value_size : OPTIONS_BUFF_SIZE))
138 : entry->type == OPTION_TYPE_DOUBLE ? (entry->default_value_size ? entry->default_value_size : sizeof(double))
139 : entry->type == OPTION_TYPE_BOOL ? (entry->default_value_size ? entry->default_value_size : sizeof(bool))
140 : (entry->default_value_size ? entry->default_value_size : sizeof(int)),
141 .default_value = entry->default_value,
142 .enum_values = entry->metadata.enum_values,
143 .enum_value_count = 0,
144 .dynamic_string = entry->owns_memory,
145 .parse = entry->type == OPTION_TYPE_CALLBACK ? registry_flags_parse : NULL,
146 .validate = entry->type == OPTION_TYPE_DOUBLE ? registry_flags_validate : NULL,
147 .validation_regex = entry->metadata.validation_pattern,
148 .on_change = entry->type == OPTION_TYPE_ACTION || (entry->type == OPTION_TYPE_STRING && entry->parse_fn) ? registry_flags_change : NULL,
149 .user_data = (void *)entry};
150 if (entry->type == OPTION_TYPE_CALLBACK || entry->type == OPTION_TYPE_ACTION)
151 option.storage_size = 0;
152 if (entry->metadata.enum_values) {
153 while (entry->metadata.enum_values[option.enum_value_count])
154 ++option.enum_value_count;
155 }
156 char config_key[256];
157 const char *config_field = entry->long_name;
158 if (entry->group && strcmp(entry->group, "OTEL") == 0 && strncmp(config_field, "otel-", 5) == 0)
159 config_field += 5;
160 if (entry->group && flags_config_make_toml_key(entry->group, config_field, config_key, sizeof(config_key)))
161 option.config_key = config_key;
162 if (!flags_schema_builder_add_option(builder, &option))
163 return SET_ERRNO(ERROR_MEMORY, "Failed to add %s to libflags schema", entry->long_name);
164 }
165 return ASCIICHAT_OK;
166}
167
169 if (!builder)
170 return SET_ERRNO(ERROR_INVALID_PARAM, "Builder is NULL");
172 for (size_t i = 0; i < g_registry_size; ++i) {
173 if (g_options_registry[i].long_name) {
175 options_builder_add_descriptor(builder, &descriptor);
176 }
177 }
178 return ASCIICHAT_OK;
179}
180
182 if (!num_options)
183 return NULL;
188 size_t count = 0;
189 for (size_t i = 0; i < g_registry_size; ++i)
190 count += (g_options_registry[i].mode_bitmask & mask) != 0;
191 option_descriptor_t *result = count ? SAFE_MALLOC(count * sizeof(*result), option_descriptor_t *) : NULL;
192 if (!result) {
193 *num_options = 0;
194 return NULL;
195 }
196 size_t out = 0;
197 for (size_t i = 0; i < g_registry_size; ++i)
198 if (g_options_registry[i].mode_bitmask & mask)
200 *num_options = out;
201 return result;
202}
203
204const option_descriptor_t *options_registry_get_for_display(asciichat_mode_t mode, bool for_binary_help, size_t *num_options) {
205 if (!num_options)
206 return NULL;
208 size_t count = 0;
209 for (size_t i = 0; i < g_registry_size; ++i)
210 count += registry_entry_applies_to_mode(&g_options_registry[i], mode, for_binary_help);
211 option_descriptor_t *result = count ? SAFE_MALLOC(count * sizeof(*result), option_descriptor_t *) : NULL;
212 if (!result) {
213 *num_options = 0;
214 return NULL;
215 }
216 size_t out = 0;
217 for (size_t i = 0; i < g_registry_size; ++i)
218 if (registry_entry_applies_to_mode(&g_options_registry[i], mode, for_binary_help))
220 *num_options = out;
221 return result;
222}
223
236
242size_t registry_get_count(void) {
244 return g_registry_size;
245}
246
247// ============================================================================
248// Completion Metadata Access (Phase 3 Implementation)
249// ============================================================================
250
252 if (!long_name) {
253 SET_ERRNO(ERROR_INVALID_PARAM, "Long name is NULL");
254 return NULL;
255 }
256
257 // Look up option in registry and return its metadata
259 for (size_t i = 0; i < g_registry_size; i++) {
260 const registry_entry_t *entry = &g_options_registry[i];
261 if (entry->long_name && strcmp(entry->long_name, long_name) == 0) {
262 // Return the metadata from the registry entry
263 return &entry->metadata;
264 }
265 }
266
267 // If not found, return empty metadata
268 static option_metadata_t empty_metadata = {0};
269 return &empty_metadata;
270}
271
272const char **options_registry_get_enum_values(const char *option_name, const char ***descriptions, size_t *count) {
273 if (!option_name || !count) {
274 SET_ERRNO(ERROR_INVALID_PARAM, "Option name is NULL or count is NULL");
275 if (count)
276 *count = 0;
277 return NULL;
278 }
279
280 const option_metadata_t *meta = options_registry_get_metadata(option_name);
281 if (!meta || meta->input_type != OPTION_INPUT_ENUM || !meta->enum_values || meta->enum_values[0] == NULL) {
282 SET_ERRNO(ERROR_NOT_FOUND, "Option '%s' not found", option_name);
283 *count = 0;
284 if (descriptions)
285 *descriptions = NULL;
286 return NULL;
287 }
288
289 // Count enum values (NULL-terminated array)
290 size_t enum_count = 0;
291 while (meta->enum_values[enum_count] != NULL) {
292 enum_count++;
293 }
294
295 *count = enum_count;
296 if (descriptions) {
297 *descriptions = meta->enum_descriptions;
298 }
299 return meta->enum_values;
300}
301
302bool options_registry_get_numeric_range(const char *option_name, int *min_out, int *max_out, int *step_out) {
303 if (!option_name || !min_out || !max_out || !step_out) {
304 SET_ERRNO(ERROR_INVALID_PARAM, "Option name is NULL or min_out, max_out, or step_out is NULL");
305 return false;
306 }
307
308 const option_metadata_t *meta = options_registry_get_metadata(option_name);
309 if (!meta || meta->input_type != OPTION_INPUT_NUMERIC) {
310 *min_out = 0;
311 *max_out = 0;
312 *step_out = 0;
313 return false;
314 }
315
316 *min_out = meta->numeric_range.min;
317 *max_out = meta->numeric_range.max;
318 *step_out = meta->numeric_range.step;
319 return true;
320}
321
322const char **options_registry_get_examples(const char *option_name, size_t *count) {
323 if (!option_name || !count) {
324 SET_ERRNO(ERROR_INVALID_PARAM, "Option name is NULL or count is NULL");
325 if (count)
326 *count = 0;
327 return NULL;
328 }
329
330 const option_metadata_t *meta = options_registry_get_metadata(option_name);
331 if (!meta || !meta->examples || meta->examples[0] == NULL) {
332 *count = 0;
333 return NULL;
334 }
335
336 // Count examples by finding NULL terminator
337 size_t example_count = 0;
338 for (size_t i = 0; meta->examples[i] != NULL; i++) {
339 example_count++;
340 }
341
342 *count = example_count;
343 return meta->examples;
344}
345
347 if (!option_name) {
348 SET_ERRNO(ERROR_INVALID_PARAM, "Option name is NULL");
349 return OPTION_INPUT_NONE;
350 }
351
352 const option_metadata_t *meta = options_registry_get_metadata(option_name);
353 if (!meta) {
354 SET_ERRNO(ERROR_NOT_FOUND, "Option '%s' not found", option_name);
355 return OPTION_INPUT_NONE;
356 }
357
358 return meta->input_type;
359}
Action option callbacks for ascii-chat.
void(* option_action_fn)(void)
Definition actions.h:228
#define SET_ERRNO(code,...)
option_input_type_t
Completion input type for smart shell completions.
Definition builder.h:185
@ OPTION_INPUT_NUMERIC
Numeric value with optional min/max/step.
Definition builder.h:188
@ OPTION_INPUT_NONE
No input (boolean flag).
Definition builder.h:186
@ OPTION_INPUT_ENUM
Choose from fixed set of enum values.
Definition builder.h:187
@ OPTION_TYPE_INT
Integer value (–count 42).
Definition builder.h:172
@ OPTION_TYPE_DOUBLE
Floating point (–ratio 1.5).
Definition builder.h:174
@ OPTION_TYPE_STRING
String value (–name foo).
Definition builder.h:173
@ OPTION_TYPE_ACTION
Action that executes and may exit (–list-webcams, etc.).
Definition builder.h:176
@ OPTION_TYPE_CALLBACK
Custom parser function.
Definition builder.h:175
@ OPTION_TYPE_BOOL
Boolean flag (–flag, no value).
Definition builder.h:171
void options_builder_add_descriptor(options_builder_t *builder, const option_descriptor_t *descriptor)
Add full option descriptor (advanced).
option_descriptor_t registry_entry_to_descriptor(const registry_entry_t *entry)
Definition core.c:157
bool registry_entry_applies_to_mode(const registry_entry_t *entry, asciichat_mode_t mode, bool for_binary_help)
Definition core.c:182
void registry_init_size(void)
Initialize registry size and metadata.
Definition core.c:107
Dedicated worker for all pending errno stacks and handled history. Signal handlers may only request a...
#define SAFE_MALLOC(size, cast)
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_NOT_FOUND
@ ERROR_MEMORY
Definition error_codes.h:55
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
asciichat_mode_t
Mode type for options parsing.
Definition options.h:916
struct options_state options_t
Immutable, RCU-published snapshot of the application's runtime configuration.
#define OPTIONS_BUFF_SIZE
Buffer size for option string values.
Definition options.h:305
option_mode_bitmask_t
Option mode bitmask.
Definition options.h:933
@ MODE_CLIENT
Client mode - network client options.
Definition options.h:918
@ MODE_MCP_SERVER
Model Context Protocol rendering server.
Definition options.h:922
@ MODE_DISCOVERY_SERVICE
Discovery server mode - session management and WebRTC signaling.
Definition options.h:920
@ MODE_SERVER
Server mode - network server options.
Definition options.h:917
@ MODE_MIRROR
Mirror mode - local webcam viewing (no network).
Definition options.h:919
@ MODE_DISCOVERY
Discovery mode - participant that can dynamically become host.
Definition options.h:921
@ OPTION_MODE_BINARY
Binary-level options (parsed before mode detection).
Definition options.h:942
@ OPTION_MODE_CLIENT
Client mode (bit 1).
Definition options.h:936
@ OPTION_MODE_DISCOVERY
Discovery mode (bit 4).
Definition options.h:939
@ OPTION_MODE_SERVER
Server mode (bit 0).
Definition options.h:935
@ OPTION_MODE_MIRROR
Mirror mode (bit 2).
Definition options.h:937
@ OPTION_MODE_NONE
No modes (invalid).
Definition options.h:934
@ OPTION_MODE_MCP_SERVER
Definition options.h:940
@ OPTION_MODE_DISCOVERY_SVC
Discovery server mode (bit 3).
Definition options.h:938
@ PALETTE_CUSTOM
User-defined via –palette-chars.
Definition palette.h:110
Shared structures and macros for registry implementation.
option_action_fn options_action_callback(const char *name, bool immediate)
deferred_action_t action
registry_entry_t g_options_registry[2048]
Definition registry.c:41
size_t g_registry_size
Definition registry.c:43
Central registry of all command-line options with mode applicability.
struct flags_schema_builder flags_schema_builder_t
const option_descriptor_t * options_registry_get_for_mode(asciichat_mode_t mode, size_t *num_options)
Get all options for a specific mode.
Definition public_api.c:181
const option_descriptor_t * options_registry_get_for_display(asciichat_mode_t mode, bool for_binary_help, size_t *num_options)
Get options for help/completions display with unified filtering.
Definition public_api.c:204
const char ** options_registry_get_enum_values(const char *option_name, const char ***descriptions, size_t *count)
Get enum values for an option.
Definition public_api.c:272
bool options_registry_get_numeric_range(const char *option_name, int *min_out, int *max_out, int *step_out)
Get numeric range for an option.
Definition public_api.c:302
size_t registry_get_count(void)
Get total number of registry entries.
Definition public_api.c:242
asciichat_error_t options_registry_add_all_to_builder(options_builder_t *builder)
Add all options from registry to builder.
Definition public_api.c:168
const char ** options_registry_get_examples(const char *option_name, size_t *count)
Get example values for an option.
Definition public_api.c:322
asciichat_error_t registry_add_all_to_flags_builder(flags_schema_builder_t *builder, option_mode_bitmask_t mode_mask)
Definition public_api.c:84
const option_metadata_t * options_registry_get_metadata(const char *long_name)
Get complete metadata for an option.
Definition public_api.c:251
const registry_entry_t * registry_get_raw(void)
Get raw access to registry for completions filtering.
Definition public_api.c:232
option_input_type_t options_registry_get_input_type(const char *option_name)
Get input type for an option.
Definition public_api.c:346
static bool size_t gotel_query_t * out
Definition queries.h:8
🔤 String Manipulation and Shell Escaping Utilities
The complete registry entry for one command-line/configuration option.
Definition builder.h:251
Completion metadata attached to one option descriptor.
Definition builder.h:201
int max
Maximum value (or 0 if no limit).
Definition builder.h:210
const char ** enum_values
Enum value strings (null-terminated, e.g., {"auto", "none", "16", "256", "truecolor",...
Definition builder.h:203
int min
Minimum value (or 0 if no limit).
Definition builder.h:209
option_input_type_t input_type
What kind of input this option expects.
Definition builder.h:221
const char ** enum_descriptions
Descriptions parallel to enum_values (null-terminated, e.g., "Auto-detect from terminal").
Definition builder.h:204
const char ** examples
Example values or command invocations (null-terminated array).
Definition builder.h:215
struct option_metadata_t::@061372117173071240020206164036331043262170062306 numeric_range
const char * validation_pattern
Optional regex pattern for validation hints.
Definition builder.h:227
int step
Step size (0 = no step, continuous).
Definition builder.h:211
Immutable parsing tables produced from an options builder.
Definition builder.h:459
bool palette_custom_set
True if custom palette was set.
Definition options.h:1222
palette_type_t palette_type
Selected palette type.
Definition options.h:1220
Registry entry - stores option definition with mode bitmask and metadata.
option_type_t type
const char * group
bool optional_arg
bool required
bool owns_memory
size_t default_value_size
const char * help_text
option_mode_bitmask_t mode_bitmask
const char * arg_placeholder
Custom argument placeholder (e.g., "SHELL [FILE]" instead of "STR").
const void * default_value
Default value (single value for all modes, or NULL if mode_default_getter is set).
const char * env_var_name
option_metadata_t metadata
Enum values, numeric ranges, examples.
char short_name
const char * long_name
bool(* parse_fn)(const char *arg, void *dest, char **error_msg)
size_t offset