aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/mds-kbdc/compile-layout.c307
-rw-r--r--src/mds-kbdc/include-stack.c8
-rw-r--r--src/mds-kbdc/include-stack.h2
3 files changed, 286 insertions, 31 deletions
diff --git a/src/mds-kbdc/compile-layout.c b/src/mds-kbdc/compile-layout.c
index d75e423..62eb925 100644
--- a/src/mds-kbdc/compile-layout.c
+++ b/src/mds-kbdc/compile-layout.c
@@ -95,6 +95,15 @@ static int compile_subtree(mds_kbdc_tree_t* restrict tree);
+static int check_function_calls_in_literal(const mds_kbdc_tree_t* restrict tree,
+ const char* restrict raw, size_t lineoff)
+{
+ (void) tree;
+ (void) raw;
+ (void) lineoff;
+ return 0; /* TODO */
+}
+
static char32_t* parse_string(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff)
{
(void) tree;
@@ -442,7 +451,7 @@ static int compile_have_range(mds_kbdc_tree_assumption_have_range_t* restrict tr
* @param tree The tree to evaluate
* @return Zero on success, -1 on error, 1 if an undefined macro is used
*/
-static int check_marco_calls(mds_kbdc_tree_t* tree)
+static int check_marco_calls(const mds_kbdc_tree_t* restrict tree)
{
#define t(...) if (rc |= r = (__VA_ARGS__), r < 0) return r
const mds_kbdc_tree_macro_t* macro;
@@ -456,7 +465,7 @@ static int check_marco_calls(mds_kbdc_tree_t* tree)
{
case C(INCLUDE):
t (mds_kbdc_include_stack_push(&(tree->include), &data));
- t (r = compile_subtree(tree->include.inner), mds_kbdc_include_stack_pop(data), r);
+ t (r = check_marco_calls(tree->include.inner), mds_kbdc_include_stack_pop(data), r);
break;
case C(FOR):
@@ -484,6 +493,182 @@ static int check_marco_calls(mds_kbdc_tree_t* tree)
/**
+ * Check that all called functions in a for-statement are already defined
+ *
+ * @param tree The tree to evaluate
+ * @return Zero on success, -1 on error, 1 if an undefined function is used
+ */
+static int check_function_calls_in_for(const mds_kbdc_tree_for_t* restrict tree)
+{
+#define t(...) if (rc |= r = check_function_calls_in_literal(__VA_ARGS__), r < 0) return r
+ size_t lineoff_first;
+ size_t lineoff_last;
+ char* restrict code = result->source_code->real_lines[tree->loc_line];
+ int r, rc = 0;
+
+ for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++);
+ for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++);
+
+ t ((const mds_kbdc_tree_t*)tree, tree->first, lineoff_first);
+ t ((const mds_kbdc_tree_t*)tree, tree->last, lineoff_last);
+
+ return rc;
+#undef t
+}
+
+
+/**
+ * Check that all called functions in an if-statement are already defined
+ *
+ * @param tree The tree to evaluate
+ * @return Zero on success, -1 on error, 1 if an undefined function is used
+ */
+static int check_function_calls_in_if(const mds_kbdc_tree_if_t* restrict tree)
+{
+ size_t lineoff;
+ char* restrict code = result->source_code->real_lines[tree->loc_line];
+
+ for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
+ return check_function_calls_in_literal((const mds_kbdc_tree_t*)tree, tree->condition, lineoff);
+}
+
+
+/**
+ * Check that all called functions in a key-combination are already defined
+ *
+ * @param tree The tree to evaluate
+ * @return Zero on success, -1 on error, 1 if an undefined function is used
+ */
+static int check_function_calls_in_keys(const mds_kbdc_tree_keys_t* restrict tree)
+{
+ return check_function_calls_in_literal((const mds_kbdc_tree_t*)tree, tree->keys, tree->loc_end);
+}
+
+
+/**
+ * Check that all called functions in a string are already defined
+ *
+ * @param tree The tree to evaluate
+ * @return Zero on success, -1 on error, 1 if an undefined function is used
+ */
+static int check_function_calls_in_string(const mds_kbdc_tree_string_t* restrict tree)
+{
+ return check_function_calls_in_literal((const mds_kbdc_tree_t*)tree, tree->string, tree->loc_end);
+}
+
+
+/**
+ * Check that all called functions are already defined
+ *
+ * @param tree The tree to evaluate
+ * @return Zero on success, -1 on error, 1 if an undefined function is used
+ */
+static int check_function_calls(const mds_kbdc_tree_t* restrict tree)
+{
+#define t(...) if (rc |= r = (__VA_ARGS__), r < 0) return r
+ void* data;
+ int r, rc = 0;
+ again:
+ if (tree == NULL)
+ return rc;
+
+ switch (tree->type)
+ {
+ case C(INCLUDE):
+ t (mds_kbdc_include_stack_push(&(tree->include), &data));
+ t (r = check_function_calls(tree->include.inner), mds_kbdc_include_stack_pop(data), r);
+ break;
+
+ case C(FOR):
+ t (check_function_calls_in_for(&(tree->for_)));
+ t (check_function_calls(tree->for_.inner));
+ break;
+
+ case C(IF):
+ t (check_function_calls_in_if(&(tree->if_)));
+ t (check_function_calls(tree->if_.inner));
+ t (check_function_calls(tree->if_.otherwise));
+ break;
+
+ case C(LET):
+ t (check_function_calls(tree->let.value));
+ break;
+
+ case C(ARRAY):
+ t (check_function_calls(tree->array.elements));
+ break;
+
+ case C(KEYS):
+ t (check_function_calls_in_keys(&(tree->keys)));
+ break;
+
+ case C(STRING):
+ t (check_function_calls_in_string(&(tree->string)));
+ break;
+
+ case C(MAP):
+ t (check_function_calls(tree->map.sequence));
+ break;
+
+ default:
+ break;
+ }
+
+ tree = tree->next;
+ goto again;
+#undef t
+}
+
+
+/**
+ * Check that a callable's name-suffix is correct
+ *
+ * @param tree The tree to inspect
+ * @return Zero on sucess, -1 on error, 1 if the name-suffix in invalid
+ */
+static int check_name_suffix(struct mds_kbdc_tree_callable* restrict tree)
+{
+ const char* restrict name = strchr(tree->name, '/');
+ const char* restrict code = result->source_code->real_lines[tree->loc_line];
+
+ if (name == NULL)
+ {
+ NEW_ERROR(tree, includes_ptr, ERROR, "name-suffix is missing");
+ goto name_error;
+ }
+ if (*++name == '\0')
+ {
+ NEW_ERROR(tree, includes_ptr, ERROR, "empty name-suffix");
+ goto name_error;
+ }
+ if (!strcmp(name, "0"))
+ return 0;
+ if (*name == '\0')
+ {
+ NEW_ERROR(tree, includes_ptr, ERROR, "leading zero in name-suffix");
+ goto name_error;
+ }
+ for (; *name; name++)
+ if ((*name < '0') || ('0' < *name))
+ {
+ NEW_ERROR(tree, includes_ptr, ERROR, "name-suffix may only contain digits");
+ goto name_error;
+ }
+
+ return 0;
+ pfail:
+ return -1;
+ name_error:
+ error->start = tree->loc_end;
+ while (code[error->start] == ' ')
+ error->start++;
+ error->end = error->start + strlen(tree->name);
+ tree->processed = PROCESS_LEVEL;
+ return 1;
+}
+
+
+/**
* Compile a function
*
* @param tree The tree to compile
@@ -491,19 +676,22 @@ static int check_marco_calls(mds_kbdc_tree_t* tree)
*/
static int compile_function(mds_kbdc_tree_function_t* restrict tree)
{
+#define t(expr) fail_if ((r = (expr), r < 0)); if (r) tree->processed = PROCESS_LEVEL
int r;
- fail_if ((r = check_marco_calls(tree->inner), r));
- if (r)
- tree->processed = PROCESS_LEVEL;
+ t (check_name_suffix((struct mds_kbdc_tree_callable*)tree));
- return 0; /* TODO */
+ /* TODO check for redefinition */
+
+ t (check_marco_calls(tree->inner));
+ t (check_function_calls(tree->inner));
+
+ /* TODO add definition */
+
+ return 0;
pfail:
return -1;
-
- /* Check redefinition */
- /* Check the suffix in the name */
- /* Check for forward- and self-references */
+#undef t
}
@@ -515,19 +703,22 @@ static int compile_function(mds_kbdc_tree_function_t* restrict tree)
*/
static int compile_macro(mds_kbdc_tree_macro_t* restrict tree)
{
- int r;
+#define t(expr) fail_if ((r = (expr), r < 0)); if (r) tree->processed = PROCESS_LEVEL
+ int r;
- fail_if ((r = check_marco_calls(tree->inner), r));
- if (r)
- tree->processed = PROCESS_LEVEL;
+ t (check_name_suffix((struct mds_kbdc_tree_callable*)tree));
- return 0; /* TODO */
+ /* TODO check for redefinition */
+
+ t (check_marco_calls(tree->inner));
+ t (check_function_calls(tree->inner));
+
+ /* TODO add definition */
+
+ return 0;
pfail:
return -1;
-
- /* Check redefinition */
- /* Check the suffix in the name */
- /* Check for forward-references */
+#undef t
}
@@ -642,30 +833,49 @@ static int compile_let(mds_kbdc_tree_let_t* restrict tree)
{
size_t lineoff;
char* restrict code = result->source_code->real_lines[tree->loc_line];
+ mds_kbdc_tree_t* value = NULL;
size_t variable;
+ int saved_errno;
for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
fail_if ((variable = parse_variable((mds_kbdc_tree_t*)tree, tree->variable, lineoff), variable == 0));
-
if (tree->processed == PROCESS_LEVEL)
return 0;
- fail_if (let(variable, NULL, tree->value, NULL, 0, 0));
+ fail_if ((value = mds_kbdc_tree_dup(tree->value), value == NULL));
+ fail_if (compile_subtree(value));
+ if ((tree->processed = value->processed) == PROCESS_LEVEL)
+ return 0;
+
+ fail_if (let(variable, NULL, value, NULL, 0, 0));
+
+ free(value);
return 0;
- pfail:
- return -1;
+ FAIL_BEGIN;
+ free(value);
+ FAIL_END;
}
+/*
+ * `compile_keys`, `compile_string`, `compile_array` and `evaluate_element`
+ * are do only compilation subprocedures that may alter the compiled nodes.
+ * This is because (1) `compile_let`, `compile_map` and `compile_macro_call`
+ * needs the compiled values, and (2) only duplicates of nodes of types
+ * `C(KEYS)`, `C(STRING)` and `C(ARRAY)` are compiled, as they can only be
+ * found with `C(LET)`-, `C(MAP)`- and `C(MACRO_CALL)`-nodes.
+ */
+
+
/**
- * Evaluate an element or argument in a mapping-, value-statement or macro call
+ * Evaluate an element or argument in a mapping-, value-, let-statement or macro call
*
* @param node The element to evaluate
* @return Zero on success, -1 on error, 1 if the element is invalid
*/
-static int evaluate_element(mds_kbdc_tree_t* node)
+static int evaluate_element(mds_kbdc_tree_t* restrict node)
{
- char32_t* data = NULL;
+ char32_t* restrict data = NULL;
int bad = 0;
for (; node; node = node->next)
@@ -676,6 +886,7 @@ static int evaluate_element(mds_kbdc_tree_t* node)
fail_if ((data = parse_keys(node, node->keys.keys, node->loc_start), data == NULL));
free(node->string.string);
node->string.string = string_encode(data);
+ free(data);
fail_if (node->string.string == NULL);
bad |= (node->processed == PROCESS_LEVEL);
}
@@ -687,6 +898,47 @@ static int evaluate_element(mds_kbdc_tree_t* node)
/**
+ * Compile a key-combination
+ *
+ * @param tree The tree to compile
+ * @return Zero on success, -1 on error
+ */
+static int compile_keys(mds_kbdc_tree_keys_t* restrict tree)
+{
+ return evaluate_element((mds_kbdc_tree_t*)tree) < 0 ? -1 : 0;
+}
+
+
+/**
+ * Compile a string
+ *
+ * @param tree The tree to compile
+ * @return Zero on success, -1 on error
+ */
+static int compile_string(mds_kbdc_tree_string_t* restrict tree)
+{
+ return evaluate_element((mds_kbdc_tree_t*)tree) < 0 ? -1 : 0;
+}
+
+
+/**
+ * Compile an array
+ *
+ * @param tree The tree to compile
+ * @return Zero on success, -1 on error
+ */
+static int compile_array(mds_kbdc_tree_array_t* restrict tree)
+{
+ int r = evaluate_element(tree->elements);
+ if (r < 0)
+ return -1;
+ if (r)
+ tree->processed = PROCESS_LEVEL;
+ return 0;
+}
+
+
+/**
* Compile a mapping- or value-statement
*
* @param tree The tree to compile
@@ -799,6 +1051,9 @@ static int compile_subtree(mds_kbdc_tree_t* restrict tree)
case C(FOR): c_ (for); break;
case C(IF): c_ (if); break;
case C(LET): c (let); break;
+ case C(KEYS): c (keys); break;
+ case C(STRING): c (string); break;
+ case C(ARRAY): c (array); break;
case C(MAP): c (map); break;
case C(MACRO_CALL): c (macro_call); break;
case C(RETURN): break_level = 3; break;
diff --git a/src/mds-kbdc/include-stack.c b/src/mds-kbdc/include-stack.c
index e3aff48..401bde5 100644
--- a/src/mds-kbdc/include-stack.c
+++ b/src/mds-kbdc/include-stack.c
@@ -31,7 +31,7 @@ static mds_kbdc_parse_error_t* error;
/**
* The `result` parameter of root procedure that requires the include stack
*/
-static mds_kbdc_parsed_t* restrict result;
+static mds_kbdc_parsed_t* result;
/**
* The original value of `result->pathname`
@@ -46,7 +46,7 @@ static mds_kbdc_source_code_t* original_source_code;
/**
* Stack of visited include-statements
*/
-static mds_kbdc_tree_include_t** restrict includes = NULL;
+static const mds_kbdc_tree_include_t** restrict includes = NULL;
/**
* The number elements allocated for `includes`
@@ -125,9 +125,9 @@ void mds_kbdc_include_stack_end(void)
* is undefined on error
* @return Zero on success, -1 on error
*/
-int mds_kbdc_include_stack_push(mds_kbdc_tree_include_t* restrict tree, void** data)
+int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t* restrict tree, void** data)
{
- mds_kbdc_tree_include_t** old = NULL;
+ const mds_kbdc_tree_include_t** old = NULL;
int saved_errno;
if (includes_ptr == includes_size)
diff --git a/src/mds-kbdc/include-stack.h b/src/mds-kbdc/include-stack.h
index 2c9fce8..6758589 100644
--- a/src/mds-kbdc/include-stack.h
+++ b/src/mds-kbdc/include-stack.h
@@ -102,7 +102,7 @@ void mds_kbdc_include_stack_end(void);
* is undefined on error
* @return Zero on success, -1 on error
*/
-int mds_kbdc_include_stack_push(mds_kbdc_tree_include_t* restrict tree, void** data);
+int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t* restrict tree, void** data);
/**
* Undo the lasted not-undone call to `mds_kbdc_include_stack_push`
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-24 13:24:32 +0000