1 files changed, 170 insertions, 21 deletions

diff --git a/src/mds-kbdc/compile-layout.c b/src/mds-kbdc/compile-layout.c
index f77daff..f49e3c2 100644
--- a/src/mds-kbdc/compile-layout.c
+++ b/src/mds-kbdc/compile-layout.c
@@ -156,6 +156,7 @@ static int set_macro(const mds_kbdc_tree_macro_t* restrict macro,
 {
   (void) macro;
   (void) macro_include_stack;
+  mds_kbdc_include_stack_free(macro_include_stack);
   return 0; /* TODO */
 }
 
@@ -186,6 +187,7 @@ static int set_function(const mds_kbdc_tree_function_t* restrict function,
 {
   (void) function;
   (void) function_include_stack;
+  mds_kbdc_include_stack_free(function_include_stack);
   return 0; /* TODO */
 }
 
@@ -247,16 +249,24 @@ static int compile_language(mds_kbdc_tree_information_language_t* restrict tree)
   char** old = NULL;
   int saved_errno;
   
-  for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
-  
+  /* Make sure the language-list fits another entry. */
   if (result->languages_ptr == result->languages_size)
     {
       result->languages_size = result->languages_size ? (result->languages_size << 1) : 1;
       fail_if (xxrealloc(old, result->languages, result->languages_size, char*));
     }
   
+  /* Locate the first character in the language-string. */
+  for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
+  /* Evaluate function calls, variable dereferences and escapes in the language-string. */
   fail_if ((data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff), data == NULL));
+  if (tree->processed == PROCESS_LEVEL)
+    return free(data), 0;
+  /* We want the string in UTF-8, not UTF-16. */
   fail_if ((code = string_encode(data), code == NULL));
+  free(data);
+  
+  /* Add the language to the language-list. */
   result->languages[result->languages_ptr++] = code;
   
   return 0;
@@ -281,17 +291,24 @@ static int compile_country(mds_kbdc_tree_information_country_t* restrict tree)
   char** old = NULL;
   int saved_errno;
   
-  for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
-  
+  /* Make sure the country-list fits another entry. */
   if (result->countries_ptr == result->countries_size)
     {
       result->countries_size = result->countries_size ? (result->countries_size << 1) : 1;
       fail_if (xxrealloc(old, result->countries, result->countries_size, char*));
     }
   
+  /* Locate the first character in the country-string. */
+  for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
+  /* Evaluate function calls, variable dereferences and escapes in the country-string. */
   fail_if ((data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff), data == NULL));
+  if (tree->processed == PROCESS_LEVEL)
+    return free(data), 0;
+  /* We want the string in UTF-8, not UTF-16. */
   fail_if ((code = string_encode(data), code == NULL));
   free(data);
+  
+  /* Add the country to the country-list. */
   result->countries[result->countries_ptr++] = code;
   
   return 0;
@@ -315,6 +332,7 @@ static int compile_variant(mds_kbdc_tree_information_variant_t* restrict tree)
   char32_t* restrict data = NULL;
   int saved_errno;
   
+  /* Make sure the variant has not already been set. */
   if (result->variant)
     {
       if (multiple_variants == 0)
@@ -323,10 +341,17 @@ static int compile_variant(mds_kbdc_tree_information_variant_t* restrict tree)
       return 0;
     }
   
+  /* Locate the first character in the variant-string. */
   for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
+  /* Evaluate function calls, variable dereferences and escapes in the variant-string. */
   fail_if ((data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff), data == NULL));
+  if (tree->processed == PROCESS_LEVEL)
+    return free(data), 0;
+  /* We want the string in UTF-8, not UTF-16. */
   fail_if ((code = string_encode(data), code == NULL));
   free(data);
+  
+  /* Store the variant. */
   result->variant = code;
   
   return 0;
@@ -347,29 +372,37 @@ static int compile_have(mds_kbdc_tree_assumption_have_t* restrict tree)
   mds_kbdc_tree_t* node = tree->data;
   char32_t* data = NULL;
   char32_t** old = NULL;
-  size_t new_size = (node->type == C(STRING)) ? result->assumed_strings_size : result->assumed_keys_size;
+  size_t new_size = 0;
   int saved_errno;
   
+  /* Make sure we can fit all assumption in the assumption list (part 1/2). */
+  new_size = (node->type == C(STRING)) ? result->assumed_strings_size : result->assumed_keys_size;
   new_size = new_size ? (new_size << 1) : 1;
   
   if (node->type == C(STRING))
     {
+      /* Evaluate function calls, variable dereferences and escapes in the string. */
       fail_if ((data = parse_string(node, node->string.string, node->loc_start), data == NULL));
       if (node->processed == PROCESS_LEVEL)
 	return free(data), 0;
+      /* Make sure we can fit all strings in the assumption list (part 2/2). */
       if (result->assumed_strings_ptr == result->assumed_strings_size)
 	fail_if (xxrealloc(old, result->assumed_strings, new_size, char*));
       result->assumed_strings_size = new_size;
+      /* Add the assumption to the list. */
       result->assumed_strings[result->assumed_strings_ptr++] = data;
     }
   else
     {
+      /* Evaluate function calls, variable dereferences and escapes in the key-combination. */
       fail_if ((data = parse_keys(node, node->keys.keys, node->loc_start), data == NULL));
       if (node->processed == PROCESS_LEVEL)
 	return free(data), 0;
+      /* Make sure we can fit all key-combinations in the assumption list (part 2/2). */
       if (result->assumed_keys_ptr == result->assumed_keys_size)
 	fail_if (xxrealloc(old, result->assumed_keys, new_size, char*));
       result->assumed_keys_size = new_size;
+      /* Add the assumption to the list. */
       result->assumed_keys[result->assumed_keys_ptr++] = data;
     }
   
@@ -397,16 +430,23 @@ static int compile_have_chars(mds_kbdc_tree_assumption_have_chars_t* restrict tr
   size_t n;
   int saved_errno;
   
+  /* Locate the first character in the list. */
   for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
+  /* Evaluate function calls, variable dereferences
+     and escapes in the charcter list. */
   fail_if ((data = parse_string((mds_kbdc_tree_t*)tree, tree->chars, lineoff), data == NULL));
-  for (n = 0; data[n] >= 0; n++);
+  if (tree->processed == PROCESS_LEVEL)
+    return free(data), 0;
   
+  /* Make sure we can fit all characters in the assumption list. */
+  for (n = 0; data[n] >= 0; n++);
   if (result->assumed_strings_ptr + n > result->assumed_strings_size)
     {
       result->assumed_strings_size += n;
       fail_if (xxrealloc(old, result->assumed_strings, result->assumed_strings_size, char*));
     }
   
+  /* Add all characters to the assumption list. */
   while (n--)
     {
       fail_if (xmalloc(character, 2, char32_t));
@@ -442,21 +482,29 @@ static int compile_have_range(mds_kbdc_tree_assumption_have_range_t* restrict tr
   size_t n;
   int saved_errno;
   
+  
+  /* Locate the first characters of both bound strings. */
   for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++);
   for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++);
   
+  /* Duplicate bounds and evaluate function calls,
+     variable dereferences and escapes in the bounds. */
   fail_if ((first = parse_string((mds_kbdc_tree_t*)tree, tree->first, lineoff_first), first == NULL));
   fail_if ((last = parse_string((mds_kbdc_tree_t*)tree, tree->last, lineoff_last), last == NULL));
   
+  /* Did one of the bound not evaluate, then stop. */
   if (tree->processed == PROCESS_LEVEL)
     goto done;
   
+  
+  /* Check that the primary bound is single-character. */
   if ((first[0] < 0) || (first[1] >= 0))
     {
       NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string");
       error->start = lineoff_first, lineoff_first = 0;
       error->end = error->start + strlen(tree->first);
     }
+  /* Check that the secondary bound is single-character. */
   if ((last[0] < 0) || (last[1] >= 0))
     {
       NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string");
@@ -464,20 +512,26 @@ static int compile_have_range(mds_kbdc_tree_assumption_have_range_t* restrict tr
       error->end = error->start + strlen(tree->last);
     }
   
+  /* Was one of the bounds not single-character, then stop. */
   if ((lineoff_first == 0) || (lineoff_last == 0))
     goto done;
   
+  
+  /* If the range is descending, swap the bounds so it is ascending.
+     (This cannot be done in for-loops as that may cause side-effects
+     to be created in the wrong order.) */
   if (*first > *last)
     *first ^= *last, *last ^= *first, *first ^= *last;
   
+  /* Make sure we can fit all characters in the assumption list. */
   n = (size_t)(*last - *first) + 1;
-  
   if (result->assumed_strings_ptr + n > result->assumed_strings_size)
     {
       result->assumed_strings_size += n;
       fail_if (xxrealloc(old, result->assumed_strings, result->assumed_strings_size, char*));
     }
   
+  /* Add all characters to the assumption list. */
   while (*first != *last)
     {
       fail_if (xmalloc(character, 2, char32_t));
@@ -671,23 +725,30 @@ 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];
   
+  /* A "/" must exist in the name to tell us how many parameters there are. */
   if (name == NULL)
     {
       NEW_ERROR(tree, ERROR, "name-suffix is missing");
       goto name_error;
     }
+  /* Do not let the suffix by just "/". */
   if (*++name == '\0')
     {
       NEW_ERROR(tree, ERROR, "empty name-suffix");
       goto name_error;
     }
+  
+  /* We are all good if the suffix is simply "/0" */
   if (!strcmp(name, "0"))
     return 0;
+  
+  /* The suffix may not have leading zeroes. */
   if (*name == '\0')
     {
       NEW_ERROR(tree, ERROR, "leading zero in name-suffix");
       goto name_error;
     }
+  /* The suffix must be a decimal, non-negative number. */
   for (; *name; name++)
     if ((*name < '0') || ('0' < *name))
       {
@@ -725,19 +786,25 @@ static int compile_function(mds_kbdc_tree_function_t* restrict tree)
   size_t arg_count;
   int r, saved_errno;
   
+  /* Check that the suffix if properly formatted. */
   t (check_name_suffix((struct mds_kbdc_tree_callable*)tree));
   
+  /* Get the function's name without suffix, and parse the suffix. */
   suffixless = tree->name;
   suffix_start = strchr(suffixless, '/');
   *suffix_start++ = '\0';
   arg_count = (size_t)atoll(suffix_start--);
   
+  /* Check that the function is not already defined as a builtin function. */
   if (builtin_function_defined(suffixless, arg_count))
     {
       NEW_ERROR(tree, ERROR, "function ‘%s’ is already defined as a builtin function", tree->name);
       *suffix_start = '/';
       return 0;
     }
+  /* Check that the function is not already defined,
+     the include-stack is used in the error-clause as
+     well as later when we list the function as defined. */
   fail_if (get_function_lax(suffixless, arg_count, &function, &function_include_stack));
   fail_if ((our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL));
   if (function)
@@ -751,9 +818,13 @@ static int compile_function(mds_kbdc_tree_function_t* restrict tree)
       return 0;
     }
   
+  /* Check the the function does not call macros or functions
+   * before they are defined, otherwise they may get defined
+   * between the definition of the function and calls to it. */
   t (check_marco_calls(tree->inner));
   t (check_function_calls(tree->inner));
   
+  /* List the function as defined. */
   *suffix_start = '/', suffix_start = NULL;
   t (set_function(tree, our_include_stack));
   
@@ -781,10 +852,13 @@ static int compile_macro(mds_kbdc_tree_macro_t* restrict tree)
   mds_kbdc_include_stack_t* our_include_stack = NULL;
   int r, saved_errno;
   
-  fail_if ((our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL));
-  
+  /* Check that the suffix if properly formatted. */
   t (check_name_suffix((struct mds_kbdc_tree_callable*)tree));
   
+  /* Check that the macro is not already defined,
+     the include-stack is used in the error-clause as
+     well as later when we list the macro as defined. */
+  fail_if ((our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL));
   t (get_macro_lax(tree->name, &macro, &macro_include_stack));
   if (macro)
     {
@@ -796,9 +870,13 @@ static int compile_macro(mds_kbdc_tree_macro_t* restrict tree)
       return 0;
     }
   
+  /* Check the the macro does not call macros or functions
+   * before they are defined, otherwise they may get defined
+   * between the definition of the macro and calls to it. */
   t (check_marco_calls(tree->inner));
   t (check_function_calls(tree->inner));
   
+  /* List the macro as defined. */
   t (set_macro(tree, our_include_stack));
   
   return 0;
@@ -828,25 +906,36 @@ static int compile_for(mds_kbdc_tree_for_t* restrict tree)
   size_t variable;
   int saved_errno;
   
+  
+  /* Locate the first character of the primary bound's string. */
   for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++);
+  /* Locate the first character of the secondary bound's string. */
   for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++);
   for (lineoff_last += strlen("to"); code[lineoff_last] == ' '; lineoff_last++);
+  /* Locate the first character of the select variable. */
   for (lineoff_var = lineoff_last + strlen(tree->variable); code[lineoff_var] == ' '; lineoff_var++);
   for (lineoff_var += strlen("as"); code[lineoff_var] == ' '; lineoff_var++);
   
+  /* Duplicate bounds and evaluate function calls,
+     variable dereferences and escapes in the bounds. */
   fail_if ((first = parse_string((mds_kbdc_tree_t*)tree, tree->first, lineoff_first), first == NULL));
   fail_if ((last = parse_string((mds_kbdc_tree_t*)tree, tree->last, lineoff_last), last == NULL));
+  /* Get the index of the selected variable. */
   fail_if ((variable = parse_variable((mds_kbdc_tree_t*)tree, tree->variable, lineoff_var), variable == 0));
   
+  /* Did one of the bound not evaluate, then stop. */
   if (tree->processed == PROCESS_LEVEL)
     goto done;
   
+  
+  /* Check that the primary bound is single-character. */
   if ((first[0] < 0) || (first[1] >= 0))
     {
       NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string");
       error->start = lineoff_first, lineoff_first = 0;
       error->end = error->start + strlen(tree->first);
     }
+  /* Check that the secondary bound is single-character. */
   if ((last[0] < 0) || (last[1] >= 0))
     {
       NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string");
@@ -854,9 +943,13 @@ static int compile_for(mds_kbdc_tree_for_t* restrict tree)
       error->end = error->start + strlen(tree->last);
     }
   
+  /* Was one of the bounds not single-character, then stop. */
   if ((lineoff_first == 0) || (lineoff_last == 0))
     goto done;
   
+  
+  /* Iterate over the loop for as long as a `return` or `break` has not
+     been encountered (without being caught elsewhere). */
   character[1] = -1;
   for (diff = (*first > *last) ? -1 : +1; (*first != *last) && (break_level < 2); *first += diff)
     {
@@ -866,9 +959,11 @@ static int compile_for(mds_kbdc_tree_for_t* restrict tree)
       fail_if (compile_subtree(tree->inner));
     }
   
+  /* Catch `break` and `continue`, they may not propagate further. */
   if (break_level < 3)
     break_level = 0;
   
+  
  done:
   free(first);
   free(last);
@@ -894,11 +989,14 @@ static int compile_if(mds_kbdc_tree_if_t* restrict tree)
   int ok, saved_errno;
   size_t i;
   
+  /* Locate the first character in the condition. */
   for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++);
-  
+  /* Evaluate function calls, variable dereferences and escapes in the condition. */
   fail_if ((data = parse_string((mds_kbdc_tree_t*)tree, tree->condition, lineoff), data == NULL));
-  fail_if (tree->processed == PROCESS_LEVEL);
+  if (tree->processed == PROCESS_LEVEL)
+    return free(data), 0;
   
+  /* Evaluate whether the evaluted value is true. */
   for (ok = 1, i = 0; data[i] >= 0; i++)
     ok &= !!(data[i]);
   free(data);
@@ -924,16 +1022,20 @@ static int compile_let(mds_kbdc_tree_let_t* restrict tree)
   size_t variable;
   int saved_errno;
   
+  /* Get the index of the selected variable. */
   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;
   
+  /* Duplicate arguments and evaluate function calls,
+     variable dereferences and escapes in the value. */
   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;
   
+  /* Set the value of the variable. */
   fail_if (let(variable, NULL, value, NULL, 0, 0));
   
   free(value);
@@ -1075,46 +1177,71 @@ static int compile_map(mds_kbdc_tree_map_t* restrict tree)
   char32_t* data = NULL;
   int r, saved_errno;
   
+  /* Duplicate arguments and evaluate function calls,
+     variable dereferences and escapes in the mapping
+     input sequence. */
   fail_if ((seq = mds_kbdc_tree_dup(old_seq), seq = NULL));
   fail_if ((bad |= evaluate_element(seq), bad < 0));
   
+  /* Duplicate arguments and evaluate function calls,
+     variable dereferences and escapes in the mapping
+     output sequence, unless this is a value-statement. */
   if (tree->result)
     {
       fail_if ((res = mds_kbdc_tree_dup(old_res), res = NULL));
       fail_if ((bad |= evaluate_element(res), bad < 0));
     }
   
+  /* Stop if any of the mapping-arguments could not be evaluated. */
   if (bad)
     goto done;
   
+  
   if (tree->result)
     {
+      /* Mapping-statement. */
+      
+      /* Check for invalid characters in the mapping-arguments. */
       fail_if ((bad |= check_nonnul(seq), bad < 0));
       fail_if ((bad |= check_nonnul(res), bad < 0));
       if (bad)
 	goto done;
       
+      /* Duplicate the mapping-statement but give it the evaluated mapping-arguments. */
       tree->sequence = seq;
       tree->result = res;
       fail_if ((dup_map = &(mds_kbdc_tree_dup((mds_kbdc_tree_t*)tree)->map), dup_map = NULL));
       tree->sequence = old_seq, seq = NULL;
       tree->result = old_res, res = NULL;
+      
+      /* Enlist the mapping for assembling. */
       fail_if ((include_stack = mds_kbdc_include_stack_save(), include_stack == NULL));
       fail_if (add_mapping(dup_map, include_stack));
+      
+      goto done;
     }
-  else
+  
+  
+  /* Value-statement */
+  
+  /* Add the value statement */
+  data = string_decode(seq->string.string);
+  fail_if (data == NULL);
+  fail_if ((r = set_return_value(data), r < 0));
+  data = NULL;
+  
+  /* Check that the value-statement is inside a function call, or has
+     side-effects by directly or indirectly calling ‘\set/3’ on an
+     array that is not shadowed by an inner function- or macro-call. */
+  if (r)
     {
-      data = string_decode(seq->string.string);
-      fail_if (data == NULL);
-      fail_if ((r = set_return_value(data), r < 0));
-      data = NULL;
-      if (r)
-	{
-	  NEW_ERROR(tree, ERROR, "value-statement outside function without side-effects");
-	  tree->processed = PROCESS_LEVEL;
-	}
+      NEW_ERROR(tree, ERROR, "value-statement outside function without side-effects");
+      tree->processed = PROCESS_LEVEL;
     }
   
+  /* TODO warn if tree->next is also a value-statement, unless this value has side-effect */
+  
+  
  done:
   mds_kbdc_tree_free(seq);
   mds_kbdc_tree_free(res);
@@ -1147,25 +1274,42 @@ static int compile_macro_call(mds_kbdc_tree_macro_call_t* restrict tree)
   size_t variable;
   int bad, saved_errno;
   
+  /* Duplicate arguments and evaluate function calls,
+     variable dereferences and escapes in the macro
+     call arguments. */
   fail_if ((arg = mds_kbdc_tree_dup(tree->arguments), arg = NULL));
   fail_if ((bad = evaluate_element(arg), bad < 0));
   if (bad)
     return 0;
   
+  /* Get the macro's subtree and include stack, if it has
+     not been defined `get_macro` will add an error message
+     and return `NULL`. */
   fail_if (get_macro(tree, &macro, &macro_include_stack));
   if (macro == NULL)
     goto done;
   
+  
+  /* Push call stack and set parameters. */
   fail_if (push_stack());
   for (arg_ = arg; arg_; arg_ = arg_->next)
     fail_if (let(variable, NULL, arg_, NULL, 0, 0));
+  
+  /* Switch include-stack to the macro's. */
   fail_if ((our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL));
   fail_if (mds_kbdc_include_stack_restore(macro_include_stack));
+  
+  /* Call the macro. */
   fail_if (compile_subtree(macro->inner));
+  
+  /* Switch back the include-stack to ours. */
   fail_if (mds_kbdc_include_stack_restore(our_include_stack));
   mds_kbdc_include_stack_free(our_include_stack), our_include_stack = NULL;
+  
+  /* Pop call stack. */
   fail_if (pop_stack());
   
+  
  done:
   break_level = 0;
   mds_kbdc_tree_free(arg);
@@ -1194,6 +1338,8 @@ static int compile_subtree(mds_kbdc_tree_t* restrict tree)
     return 0;
   
   if (tree->processed == PROCESS_LEVEL)
+    /* An error has occurred here before, lets skip it so
+     * we do not deluge the user with errors. */
     goto next;
   
   switch (tree->type)
@@ -1230,6 +1376,9 @@ static int compile_subtree(mds_kbdc_tree_t* restrict tree)
   
  next:
   if (break_level)
+    /* If a `continue`, `break` or `return` has been encountered,
+     * we are done here and should return to whence we came and
+     * let the subcompiler of that construct deal with it. */
     return 0;
   
   tree = tree->next;