hectic-lab/util.nix
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: hectic C: template parse

Browse Source
This commit is contained in:
yukkop
2025-05-04 13:49:29 +00:00
parent e800f11103
commit 9b045b71f9
4 changed files with 390 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
package/c/hectic/docs/templater.md
View File

@@ -123,16 +123,16 @@ Includes content from other templates.
}
```
## Function Tags
## Execution Tags
**Note:** Currently not included in C library; implemented as a wrapper on applicable platforms.
Enables calling functions with arguments.
Enables calling functions with arguments, or execute code. Have hardcoded context var - alows use template context
- **Prefix**
Denotes a function call.
*Example:* `exec` | *(Empty)*
*Function Example:*
```tpl
{% exec my_function(arg1, arg2, 'literal') %}
{% exec RETURN my_function(context->arg1, context->arg2, 'literal') %}
{% exec RETURN 'aaaaa' %}
```
@@ -143,3 +143,32 @@ Enables calling functions with arguments.
- **Missing Fields/Functions/Templates:** Configurable to either return an error or warning.
- **Circular Includes:** Detect when possible.
- **No Shadowing:** Variables defined in section tags must not conflict with context variable names, otherwise, return an error.
## Shared example
```tpl
<div>text before<div>
{% include inner_template %}
{% name %}
{% for item in array do
some text: {% name2 %}
{% item.name %}
%}
<div>code insertion:</div>
{% execute
context + '{"name3": "zalupa"}';
IF context->condition THEN
RAISE INFO 'some log';
RETURN 'some text';
END
RETURN 'some other text';
%}
<div id="footer">...</div>
```

339
package/c/hectic/hectic.c
View File

@@ -2241,36 +2241,70 @@ char *log_rules_to_debug_str__(CTX_DECLARATION, char *name, LogRule *self, PtrSe
return result;
}
// ----------
// -- View --
// ----------
View view_create(const void *data, size_t len, size_t isize) {
View view = { .data = data, .len = len, .isize = isize };
return view;
}
View string_to_view(const char *str) {
return view_create(str, strlen(str), sizeof(char));
}
View *string_to_view_ptr__(POSITION_INFO_DECLARATION, Arena *arena, const char *str) {
View *view = arena_alloc__(POSITION_INFO, arena, sizeof(View));
const View tmp = string_to_view(str);
*(void **)&view->data = (void *)tmp.data;
*(size_t *)&view->len = tmp.len;
*(size_t *)&view->isize = tmp.isize;
return view;
}
// ---------------
// -- Templater --
// ---------------
// Look at package\c\hectic\docs\templater.md
TemplateConfig template_default_config__(POSITION_INFO_DECLARATION) {
TemplateConfig template_default_config__(POSITION_INFO_DECLARATION, Arena *arena) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "TEMPLATE: Default config");
TemplateConfig config;
config.Syntax.Braces.open = "{%";
config.Syntax.Braces.close = "%}";
config.Syntax.Section.control = "for ";
config.Syntax.Section.source = " in ";
config.Syntax.Section.begin = " do ";
config.Syntax.Interpolate.invoke = "";
config.Syntax.Include.invoke = "include ";
config.Syntax.Execute.invoke = "exec ";
config.Syntax.nesting = "->";
TemplateConfig config = {
.Syntax = {
.Braces = {
.open = string_to_view_ptr__(POSITION_INFO, arena, "{%"),
.close = string_to_view_ptr__(POSITION_INFO, arena, "%}")
},
.Section = {
.control = string_to_view_ptr__(POSITION_INFO, arena, "for "),
.source = string_to_view_ptr__(POSITION_INFO, arena, " in "),
.begin = string_to_view_ptr__(POSITION_INFO, arena, " do ")
},
.Interpolate = {
.invoke = string_to_view_ptr__(POSITION_INFO, arena, "")
},
.Include = {
.invoke = string_to_view_ptr__(POSITION_INFO, arena, "include ")
},
.Execute = {
.invoke = string_to_view_ptr__(POSITION_INFO, arena, "exec ")
},
.nesting = string_to_view_ptr__(POSITION_INFO, arena, "->")
}
};
return config;
}
#define CHECK_CONFIG_STR(field, name) \
do { \
if (config->Syntax.field == NULL) { \
if (config->Syntax.field->data == NULL) { \
raise_message(LOG_LEVEL_EXCEPTION, POSITION_INFO, "VALIDATE: " name " is NULL"); \
return false; \
} \
if (strlen(config->Syntax.field) > TEMPLATE_MAX_PREFIX_LEN) { \
if (config->Syntax.field->len > TEMPLATE_MAX_PREFIX_LEN) { \
raise_message(LOG_LEVEL_EXCEPTION, POSITION_INFO, "VALIDATE: " name " is too long"); \
return false; \
} \
@@ -2299,42 +2333,95 @@ bool template_validate_config__(POSITION_INFO_DECLARATION, const TemplateConfig
#undef CHECK_CONFIG_STR
#define TEMPLATE_ASSERT_SYNTAX(pattern, message_arg, code_arg) \
if (strncmp(*s, pattern, strlen(pattern))) { \
if (strncmp(*s, pattern, strlen(pattern)) == 0) { \
raise_message(LOG_LEVEL_EXCEPTION, POSITION_INFO, "PARSE: " message_arg); \
return RESULT_ERROR(TemplateResult, code_arg, message_arg); \
}
TemplateValue init_template_value__(POSITION_INFO_DECLARATION, TemplateNodeType type) {
TemplateValue value;
switch (type) {
case TEMPLATE_NODE_TEXT:
value.text.content = NULL;
break;
case TEMPLATE_NODE_INTERPOLATE:
value.interpolate.key = NULL;
break;
case TEMPLATE_NODE_SECTION:
value.section.iterator = NULL;
value.section.collection = NULL;
value.section.body = NULL;
break;
case TEMPLATE_NODE_EXECUTE:
value.execute.code = NULL;
break;
case TEMPLATE_NODE_INCLUDE:
value.include.key = NULL;
break;
default:
raise_message(LOG_LEVEL_EXCEPTION, POSITION_INFO, "INIT: Unknown node type");
exit(1);
}
return value;
}
TemplateNode init_template_node__(POSITION_INFO_DECLARATION, Arena *arena, TemplateNodeType type) {
TemplateNode node;
node.next = NULL;
node.type = type;
node.value = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateValue));
*node.value = init_template_value__(POSITION_INFO, type);
return node;
}
TemplateResult init_template_result__(POSITION_INFO_DECLARATION, Arena *arena, TemplateNodeType type) {
TemplateResult result;
result.type = RESULT_SOME;
result.Result.some = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateNode));
*result.Result.some = init_template_node__(POSITION_INFO, arena, type);
return result;
}
TemplateNode new_template_node__(TemplateNodeType type, TemplateValue *value) {
TemplateNode node;
node.next = NULL;
node.type = type;
node.value = value;
return node;
}
TemplateResult template_parse__(POSITION_INFO_DECLARATION, Arena *arena, const char **s, const TemplateConfig *config);
TemplateResult template_parse_interpolation__(POSITION_INFO_DECLARATION, Arena *arena, const char **s_ptr, const TemplateConfig *config) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Interpolation");
TemplateResult result;
TemplateResult result = init_template_result__(POSITION_INFO, arena, TEMPLATE_NODE_INTERPOLATE);
const char **s = s_ptr;
// Skip to the content of the interpolation
*s += strlen(config->Syntax.Braces.open);
*s += config->Syntax.Braces.open->len;
*s = skip_whitespace(*s);
*s += strlen(config->Syntax.Interpolate.invoke);
*s += config->Syntax.Interpolate.invoke->len;
*s = skip_whitespace(*s);
const char *key_start = *s;
while (isalnum(**s)) {
if (**s == ' ' || strncmp(*s, config->Syntax.Braces.close, strlen(config->Syntax.Braces.close))) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open, "Nested tag in interpolation", TEMPLATE_ERROR_NESTED_INTERPOLATION);
while (**s != '\0') {
if (isspace(**s) || strncmp(*s, config->Syntax.Braces.close->data, config->Syntax.Braces.close->len) == 0) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open->data, "Nested tag in interpolation", TEMPLATE_ERROR_NESTED_INTERPOLATION);
(*s)++;
}
size_t key_len = *s - key_start;
result.type = RESULT_SOME;
result.Result.some.value.interpolate.key = arena_strncpy__(POSITION_INFO, arena, key_start, key_len);
result.Result.some.type = TEMPLATE_NODE_INTERPOLATE;
char *key = arena_strncpy__(POSITION_INFO, arena, key_start, key_len);
*s_ptr = *s + strlen(config->Syntax.Braces.close);
result.Result.some->value->interpolate.key = key;
*s = skip_whitespace(*s);
*s_ptr = *s + config->Syntax.Braces.close->len;
return result;
}
@@ -2342,46 +2429,44 @@ TemplateResult template_parse_interpolation__(POSITION_INFO_DECLARATION, Arena *
TemplateResult template_parse_section__(POSITION_INFO_DECLARATION, Arena *arena, const char **s_ptr, const TemplateConfig *config) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Section");
TemplateResult result;
result.type = RESULT_SOME;
result.Result.some.type = TEMPLATE_NODE_SECTION;
TemplateResult result = init_template_result__(POSITION_INFO, arena, TEMPLATE_NODE_SECTION);
const char **s = s_ptr;
// Skip to the content of the section
*s += strlen(config->Syntax.Braces.open);
*s += config->Syntax.Braces.open->len;
*s = skip_whitespace(*s);
*s += strlen(config->Syntax.Section.control);
*s += config->Syntax.Section.control->len;
// Find the iterator name
*s = skip_whitespace(*s);
const char *iterator_start = *s;
while (isalnum(**s)) {
if (**s == ' ' || **s == '\n' || **s == '\t' || strncmp(*s, config->Syntax.Section.source, strlen(config->Syntax.Section.source))) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.close, "Unexpected section end", TEMPLATE_ERROR_UNEXPECTED_SECTION_END);
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open, "Nested tag in section element name", TEMPLATE_ERROR_NESTED_SECTION_ITERATOR);
while (**s != '\0') {
if (**s == ' ' || **s == '\n' || **s == '\t' || strncmp(*s, config->Syntax.Section.source->data, config->Syntax.Section.source->len) == 0) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.close->data, "Unexpected section end", TEMPLATE_ERROR_UNEXPECTED_SECTION_END);
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open->data, "Nested tag in section element name", TEMPLATE_ERROR_NESTED_SECTION_ITERATOR);
(*s)++;
}
size_t iterator_len = *s - iterator_start;
result.Result.some.value.section.iterator = arena_strncpy__(POSITION_INFO, arena, iterator_start, iterator_len);
result.Result.some->value->section.iterator = arena_strncpy__(POSITION_INFO, arena, iterator_start, iterator_len);
// Find the collection name
*s = skip_whitespace(*s);
const char *collection_start = *s;
while (isalnum(**s)) {
if (**s == ' ' || **s == '\n' || **s == '\t' || strncmp(*s, config->Syntax.Section.begin, strlen(config->Syntax.Section.begin))) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.close, "Unexpected section end", TEMPLATE_ERROR_UNEXPECTED_SECTION_END);
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open, "Nested tag in section iterator", TEMPLATE_ERROR_NESTED_SECTION_ITERATOR);
while (**s != '\0') {
if (**s == ' ' || **s == '\n' || **s == '\t' || strncmp(*s, config->Syntax.Section.begin->data, config->Syntax.Section.begin->len) == 0) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.close->data, "Unexpected section end", TEMPLATE_ERROR_UNEXPECTED_SECTION_END);
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open->data, "Nested tag in section iterator", TEMPLATE_ERROR_NESTED_SECTION_ITERATOR);
(*s)++;
}
size_t collection_len = *s - collection_start;
result.Result.some.value.section.collection = arena_strncpy__(POSITION_INFO, arena, collection_start, collection_len);
result.Result.some->value->section.collection = arena_strncpy__(POSITION_INFO, arena, collection_start, collection_len);
// Parse the body
TemplateResult body_result = template_parse__(POSITION_INFO, arena, s, config);
@@ -2389,40 +2474,39 @@ TemplateResult template_parse_section__(POSITION_INFO_DECLARATION, Arena *arena,
return body_result;
}
result.Result.some.value.section.body = &body_result.Result.some;
result.Result.some->value->section.body = body_result.Result.some;
*s_ptr = *s + strlen(config->Syntax.Braces.close);
*s_ptr = *s + config->Syntax.Braces.close->len;
return result;
}
TemplateResult template_parse_include__(POSITION_INFO_DECLARATION, Arena *arena, const char **s_ptr, const TemplateConfig *config) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Include");
TemplateResult result;
result.type = RESULT_SOME;
result.Result.some.type = TEMPLATE_NODE_INCLUDE;
TemplateResult result = init_template_result__(POSITION_INFO, arena, TEMPLATE_NODE_INCLUDE);
const char **s = s_ptr;
// Skip to the content of the include
*s += strlen(config->Syntax.Braces.open);
*s += config->Syntax.Braces.open->len;
*s = skip_whitespace(*s);
*s += strlen(config->Syntax.Include.invoke);
*s += config->Syntax.Include.invoke->len;
*s = skip_whitespace(*s);
const char *include_start = *s;
while (isalnum(**s)) {
if (**s == ' ' || **s == '\n' || **s == '\t' || strncmp(*s, config->Syntax.Braces.close, strlen(config->Syntax.Braces.close))) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open, "Nested tag in include", TEMPLATE_ERROR_NESTED_INCLUDE);
while (**s != '\0') {
if (**s == ' ' || **s == '\n' || **s == '\t' || strncmp(*s, config->Syntax.Braces.close->data, config->Syntax.Braces.close->len) == 0) break;
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open->data, "Nested tag in include", TEMPLATE_ERROR_NESTED_INCLUDE);
(*s)++;
}
size_t include_len = *s - include_start;
result.Result.some.value.include.key = arena_strncpy__(POSITION_INFO, arena, include_start, include_len);
result.Result.some->value->include.key = arena_strncpy__(POSITION_INFO, arena, include_start, include_len);
*s_ptr = *s + strlen(config->Syntax.Braces.close);
*s_ptr = *s + config->Syntax.Braces.close->len;
return result;
}
@@ -2430,28 +2514,26 @@ TemplateResult template_parse_include__(POSITION_INFO_DECLARATION, Arena *arena,
TemplateResult template_parse_execute__(POSITION_INFO_DECLARATION, Arena *arena, const char **s_ptr, const TemplateConfig *config) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Execute");
TemplateResult result;
result.type = RESULT_SOME;
result.Result.some.type = TEMPLATE_NODE_EXECUTE;
TemplateResult result = init_template_result__(POSITION_INFO, arena, TEMPLATE_NODE_EXECUTE);
const char **s = s_ptr;
*s += strlen(config->Syntax.Braces.open);
*s += config->Syntax.Braces.open->len;
*s = skip_whitespace(*s);
*s += strlen(config->Syntax.Execute.invoke);
*s += config->Syntax.Execute.invoke->len;
*s = skip_whitespace(*s);
const char *code_start = *s;
while (strncmp(*s, config->Syntax.Braces.close, strlen(config->Syntax.Braces.close))) {
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open, "Nested tag in execute", TEMPLATE_ERROR_NESTED_EXECUTE);
while (strncmp(*s, config->Syntax.Braces.close->data, config->Syntax.Braces.close->len) == 0) {
TEMPLATE_ASSERT_SYNTAX(config->Syntax.Braces.open->data, "Nested tag in execute", TEMPLATE_ERROR_NESTED_EXECUTE);
(*s)++;
}
size_t code_len = *s - code_start;
result.Result.some.value.execute.code = arena_strncpy__(POSITION_INFO, arena, code_start, code_len);
result.Result.some->value->execute.code = arena_strncpy__(POSITION_INFO, arena, code_start, code_len);
*s_ptr = *s + strlen(config->Syntax.Braces.close);
*s_ptr = *s + config->Syntax.Braces.close->len;
return result;
}
@@ -2472,62 +2554,129 @@ TemplateResult template_parse__(POSITION_INFO_DECLARATION, Arena *arena, const c
const char *start = *s;
TemplateNode *root = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateNode));
*root = init_template_node__(POSITION_INFO, arena, TEMPLATE_NODE_TEXT);
TemplateNode *current = root;
bool current_node_filled = false;
int open_brace_len = strlen(config->Syntax.Braces.open);
int open_brace_len = config->Syntax.Braces.open->len;
while (*s) {
// Find the first open brace
if (strncmp(*s, config->Syntax.Braces.open, open_brace_len) == 0) {
// Add text node if there is any text before the tag
while (*s && **s != '\0') {
if (strncmp(*s, config->Syntax.Braces.open->data, open_brace_len) == 0) {
if (start != *s) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Text node: %s", arena_strncpy__(POSITION_INFO, DISPOSABLE_ARENA, start, *s - start));
current->type = TEMPLATE_NODE_TEXT;
current->value.text.content = arena_strncpy__(POSITION_INFO, arena, start, *s - start);
if (current_node_filled) {
TemplateNode *new_node = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateNode));
*new_node = init_template_node__(POSITION_INFO, arena, TEMPLATE_NODE_TEXT);
current->next = new_node;
current = new_node;
} else {
current->type = TEMPLATE_NODE_TEXT;
*current->value = init_template_value__(POSITION_INFO, TEMPLATE_NODE_TEXT);
}
current->value->text.content = arena_strncpy__(POSITION_INFO, arena, start, *s - start);
current_node_filled = true;
}
// Deside tag type by prefix
// Determine tag type by prefix
TemplateResult current_result;
{
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Found tag");
const char *tag_prefix = *s + open_brace_len;
tag_prefix = skip_whitespace(tag_prefix);
raise_trace("tag_prefix: %p", tag_prefix);
raise_trace("tag_prefix: %p", tag_prefix);
if (strncmp(tag_prefix, config->Syntax.Section.control, strlen(config->Syntax.Section.control)) == 0) {
typedef struct {
const View * const prefix;
int tag_type;
} PrefixMatch;
PrefixMatch matches[] = {
{config->Syntax.Section.control, 1},
{config->Syntax.Interpolate.invoke, 2},
{config->Syntax.Include.invoke, 3},
{config->Syntax.Execute.invoke, 4}
};
int matched_type = 0;
size_t max_length = 0;
// Find longest match (in case when one name of tage is part of another)
for (int i = 0; i < 4; i++) {
if (strncmp(tag_prefix, matches[i].prefix->data, matches[i].prefix->len) == 0) {
// NOTE(yukkop): >= becouse one of the strings may be ""
if (matches[i].prefix->len >= max_length) {
max_length = matches[i].prefix->len;
matched_type = matches[i].tag_type;
}
}
}
if (matched_type == 1) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Section tag");
current_result = template_parse_section__(POSITION_INFO, arena, s, config);
} else if (strncmp(tag_prefix, config->Syntax.Interpolate.invoke, strlen(config->Syntax.Interpolate.invoke)) == 0) {
start = *s;
} else if (matched_type == 2) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Interpolation tag");
current_result = template_parse_interpolation__(POSITION_INFO, arena, s, config);
} else if (strncmp(tag_prefix, config->Syntax.Include.invoke, strlen(config->Syntax.Include.invoke)) == 0) {
start = *s;
} else if (matched_type == 3) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Include tag");
current_result = template_parse_include__(POSITION_INFO, arena, s, config);
} else if (strncmp(tag_prefix, config->Syntax.Execute.invoke, strlen(config->Syntax.Execute.invoke)) == 0) {
start = *s;
} else if (matched_type == 4) {
raise_message(LOG_LEVEL_TRACE, POSITION_INFO, "PARSE: Execute tag");
current_result = template_parse_execute__(POSITION_INFO, arena, s, config);
start = *s;
} else {
raise_message(LOG_LEVEL_EXCEPTION, POSITION_INFO, "PARSE: Unknown tag prefix: %s", slice_create__(POSITION_INFO, 1, (char *)tag_prefix, strlen(tag_prefix), 0, TEMPLATE_MAX_PREFIX_LEN));
return RESULT_ERROR(TemplateResult, TEMPLATE_ERROR_UNKNOWN_TAG, "Unknown tag prefix");
}
TRY(current_result);
}
*current = current_result.Result.some;
current->next = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateNode));
current = current->next;
if (current_node_filled) {
// SAFETY(yukkop): NO init necessary here
TemplateNode *new_node = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateNode));
*new_node = *current_result.Result.some;
current->next = new_node;
current = new_node;
} else {
*current = *current_result.Result.some;
}
current_node_filled = true;
}
(*s)++;
if (**s != '\0') {
(*s)++;
}
}
// Add text node if there is any text after the last tag
if (start != *s) {
current->type = TEMPLATE_NODE_TEXT;
current->value.text.content = arena_strncpy__(POSITION_INFO, arena, start, *s - start);
if (current_node_filled) {
TemplateNode *new_node = arena_alloc__(POSITION_INFO, arena, sizeof(TemplateNode));
*new_node = init_template_node__(POSITION_INFO, arena, TEMPLATE_NODE_TEXT);
current->next = new_node;
current = new_node;
} else {
current->type = TEMPLATE_NODE_TEXT;
*current->value = init_template_value__(POSITION_INFO, TEMPLATE_NODE_TEXT);
}
current->value->text.content = arena_strncpy__(POSITION_INFO, arena, start, *s - start);
current_node_filled = true;
}
// Set null when node is not filled
if (!current_node_filled && current == root) {
root->type = TEMPLATE_NODE_TEXT;
*root->value = init_template_value__(POSITION_INFO, TEMPLATE_NODE_TEXT);
root->value->text.content = arena_strncpy__(POSITION_INFO, arena, "", 0);
}
return RESULT_SOME(TemplateResult, *root);
@@ -2608,10 +2757,9 @@ char *template_value_to_debug_str__(POSITION_INFO_DECLARATION, Arena *arena, con
char *template_node_to_debug_str__(POSITION_INFO_DECLARATION, Arena *arena, const char *name, const TemplateNode *self, PtrSet *visited) {
char *result = arena_alloc(arena, MEM_KiB);
STRUCT_TO_DEBUG_STR(arena, result, TemplateNode, name, self, visited, 4,
STRUCT_TO_DEBUG_STR(arena, result, TemplateNode, name, self, visited, 3,
enum_to_debug_str__(POSITION_INFO, arena, "type", self->type, template_node_type_to_string(self->type)),
template_value_to_debug_str__(POSITION_INFO, arena, "value", &self->value, self->type, visited),
template_node_to_debug_str__(POSITION_INFO, arena, "children", self->children, visited),
template_value_to_debug_str__(POSITION_INFO, arena, "value", self->value, self->type, visited),
template_node_to_debug_str__(POSITION_INFO, arena, "next", self->next, visited)
);
return result;
@@ -2644,38 +2792,29 @@ char *template_node_to_json_str__(POSITION_INFO_DECLARATION, Arena *arena, const
switch (node->type) {
case TEMPLATE_NODE_SECTION:
APPEND("\"content\":{\"iterator\":\"%s\",\"collection\":\"%s\"}",
node->value.section.iterator,
node->value.section.collection);
char *body_str = template_node_to_json_str__(POSITION_INFO, arena, node->value.section.body, depth + 1);
node->value->section.iterator,
node->value->section.collection);
char *body_str = template_node_to_json_str__(POSITION_INFO, arena, node->value->section.body, depth + 1);
if (body_str) {
APPEND(",\"body\":%s", body_str);
}
break;
case TEMPLATE_NODE_INTERPOLATE:
APPEND("\"content\":{\"key\":\"%s\"}", node->value.interpolate.key);
APPEND("\"content\":{\"key\":\"%s\"}", node->value->interpolate.key);
break;
case TEMPLATE_NODE_EXECUTE:
APPEND("\"content\":{\"code\":\"%s\"}", node->value.execute.code);
APPEND("\"content\":{\"code\":\"%s\"}", node->value->execute.code);
break;
case TEMPLATE_NODE_INCLUDE:
APPEND("\"content\":{\"key\":\"%s\"}", node->value.include.key);
APPEND("\"content\":{\"key\":\"%s\"}", node->value->include.key);
break;
case TEMPLATE_NODE_TEXT:
APPEND("\"content\":{\"content\":\"%s\"}", node->value.text.content);
APPEND("\"content\":{\"content\":\"%s\"}", node->value->text.content);
break;
default:
break;
}
if (node->children) {
APPEND(",\"children\":[");
char *child_str = template_node_to_json_str__(POSITION_INFO, arena, node->children, depth + 1);
if (child_str) {
APPEND(",%s", child_str);
}
APPEND("]");
}
APPEND("}");
if (node->next) {

50
package/c/hectic/hectic.h
View File

@@ -147,7 +147,7 @@ typedef struct {
ResultType type; \
union { \
HecticError error; \
some_type some; \
some_type *some; \
} Result; \
} name##Result
@@ -166,11 +166,11 @@ typedef struct {
#define RESULT_ERROR_CODE(result) (result.Result.error.code)
#define RESULT_ERROR_MESSAGE(result) (result.Result.error.message)
#define RESULT_SOME_VALUE(result) (result.Result.some)
#define RESULT_SOME_VALUE(result) (*result.Result.some)
#define RESULT_ERROR_VALUE(result) (result.Result.error)
#define RESULT_SOME(result_type, value) \
(result_type) { .type = RESULT_SOME, .Result.some = value }
(result_type) { .type = RESULT_SOME, .Result.some = &value }
#define RESULT_ERROR(result_type, error_code, error_message) \
(result_type) { .type = RESULT_ERROR, .Result.error = { .code = error_code, .message = error_message } }
@@ -427,7 +427,7 @@ static Arena disposable_arena __attribute__((unused)) = {0};
#define DISPOSABLE_ARENA __extension__ ({ \
if (disposable_arena.begin == NULL) { \
disposable_arena = arena_init__(__FILE__, __func__, __LINE__, MEM_MiB); \
disposable_arena = arena_init__(__FILE__, __func__, __LINE__, MEM_MiB * 8); \
} else { \
arena_reset(&disposable_arena); \
} \
@@ -726,6 +726,16 @@ char* slice_to_debug_str__(const char* file, const char* func, int line, Arena *
#define slice_to_debug_str(arena, slice) slice_to_debug_str__(__FILE__, __func__, __LINE__, arena, slice)
// ----------
// -- View --
// ----------
typedef struct {
const void * const data;
const size_t len;
const size_t isize;
} View;
// ---------------
// -- Templater --
// ---------------
@@ -743,24 +753,24 @@ typedef enum {
typedef struct {
struct {
struct {
const char *open; // Default: "{%"
const char *close; // Default: "%}"
const View * const open; // Default: "{%"
const View * const close; // Default: "%}"
} Braces;
struct {
const char *control; // default: "for "
const char *source; // default: " in "
const char *begin; // default: " do "
const View * const control; // default: "for "
const View * const source; // default: " in "
const View * const begin; // default: " do "
} Section;
struct {
const char *invoke; // default: ""
const View * const invoke; // default: ""
} Interpolate;
struct {
const char *invoke; // default: "include "
const View * const invoke; // default: "include "
} Include;
struct {
const char *invoke; // default: "exec "
const View * const invoke; // default: "exec "
} Execute;
const char *nesting; // default: "->"
const View * const nesting; // default: "->"
} Syntax;
} TemplateConfig;
@@ -798,16 +808,15 @@ typedef union {
struct TemplateNode {
TemplateNodeType type;
TemplateValue value;
TemplateNode *children; // child nodes
TemplateNode *next; // sibling nodes
TemplateValue *value;
TemplateNode *next;
};
RESULT(Template, TemplateNode);
TemplateResult template_parse__(const char *file, const char *func, int line, Arena *arena, const char **s, const TemplateConfig *config);
TemplateConfig template_default_config__(const char *file, const char *func, int line);
TemplateConfig template_default_config__(const char *file, const char *func, int line, Arena *arena);
char *template_node_to_debug_str__(const char *file, const char *func, int line, Arena *arena, const char *name, const TemplateNode *self, PtrSet *visited);
@@ -815,7 +824,7 @@ char *template_node_to_json_str__(const char *file, const char *func, int line,
#define template_parse(arena, s, config) template_parse__(__FILE__, __func__, __LINE__, arena, s, config)
#define template_default_config() template_default_config__(__FILE__, __func__, __LINE__)
#define template_default_config(arena) template_default_config__(__FILE__, __func__, __LINE__, arena)
#define TEMPLATE_NODE_TO_DEBUG_STR(arena, name, node) \
template_node_to_debug_str__(__FILE__, __func__, __LINE__, arena, name, node, ptrset_init(arena))
@@ -823,4 +832,9 @@ char *template_node_to_json_str__(const char *file, const char *func, int line,
#define TEMPLATE_NODE_TO_JSON_STR(arena, node) \
template_node_to_json_str__(__FILE__, __func__, __LINE__, arena, node, 0)
TemplateNode init_template_node__(const char *file, const char *func, int line, Arena *arena, TemplateNodeType type);
#define init_template_node(arena, type) \
init_template_node__(__FILE__, __func__, __LINE__, arena, type)
#endif // EPRINTF_H

130
package/c/hectic/test/06-templater.c
View File

@@ -14,7 +14,6 @@
" content = %p \"Hello\"\n" \
" } %p\n" \
" } %p,\n" \
" struct TemplateNode children = NULL,\n" \
" struct TemplateNode next = {\n" \
" enum type = INTERPOLATE 1 ,\n" \
" union TemplateValue value = {\n" \
@@ -22,7 +21,6 @@
" key = %p \"name\"\n" \
" } %p\n" \
" } %p,\n" \
" struct TemplateNode children = NULL,\n" \
" struct TemplateNode next = {\n" \
" enum type = TEXT 0 ,\n" \
" union TemplateValue value = {\n" \
@@ -30,7 +28,6 @@
" content = %p \"!\"\n" \
" } %p\n" \
" } %p,\n" \
" struct TemplateNode children = NULL,\n" \
" struct TemplateNode next = NULL\n" \
" } %p\n" \
" } %p\n" \
@@ -50,31 +47,29 @@
" content = %p \"Loop content\"\n" \
" } %p\n" \
" } %p,\n" \
" struct TemplateNode children = NULL,\n" \
" struct TemplateNode next = NULL\n" \
" } %p\n" \
" } %p\n" \
" } %p,\n" \
" struct TemplateNode children = NULL,\n" \
" struct TemplateNode next = NULL\n" \
"} %p\n"
static void test_template_node_to_debug_str(Arena *arena) {
TemplateNode *root = arena_alloc(arena, sizeof(TemplateNode));
root->type = TEMPLATE_NODE_TEXT;
root->value.text.content = arena_strncpy(arena, "Hello", 5);
*root = init_template_node(arena, TEMPLATE_NODE_TEXT);
root->value->text.content = arena_strncpy(arena, "Hello", 5);
root->next = arena_alloc(arena, sizeof(TemplateNode));
root->next->type = TEMPLATE_NODE_INTERPOLATE;
root->next->value.interpolate.key = arena_strncpy(arena, "name", 4);
*root->next = init_template_node(arena, TEMPLATE_NODE_INTERPOLATE);
root->next->value->interpolate.key = arena_strncpy(arena, "name", 4);
root->next->next = arena_alloc(arena, sizeof(TemplateNode));
root->next->next->type = TEMPLATE_NODE_TEXT;
root->next->next->value.text.content = arena_strncpy(arena, "!", 1);
*root->next->next = init_template_node(arena, TEMPLATE_NODE_TEXT);
root->next->next->value->text.content = arena_strncpy(arena, "!", 1);
char *debug_str = debug_to_pretty_str(arena, TEMPLATE_NODE_TO_DEBUG_STR(arena, "root", root));
raise_log("debug_str: \n%s", debug_str);
raise_notice("debug_str: \n%s", debug_str);
{ // some debug output
Arena *debug_arena = DISPOSABLE_ARENA;
@@ -85,21 +80,21 @@ static void test_template_node_to_debug_str(Arena *arena) {
char *expected_debug_str = arena_alloc(arena, MEM_KiB);
sprintf(expected_debug_str, TEST_TEMPLATE_NODE_TO_DEBUG_STR,
(void*)root->value.text.content,
(void*)&root->value.text,
(void*)&root->value,
(void*)root->next->value.interpolate.key,
(void*)&root->next->value.interpolate,
(void*)&root->next->value,
(void*)root->next->next->value.text.content,
(void*)&root->next->next->value.text,
(void*)&root->next->next->value,
(void*)root->value->text.content,
(void*)&root->value->text,
(void*)root->value,
(void*)root->next->value->interpolate.key,
(void*)&root->next->value->interpolate,
(void*)root->next->value,
(void*)root->next->next->value->text.content,
(void*)&root->next->next->value->text,
(void*)root->next->next->value,
(void*)root->next->next,
(void*)root->next,
(void*)root
);
raise_log("expected_debug_str: \n%s", expected_debug_str);
raise_notice("expected_debug_str: \n%s", expected_debug_str);
assert(strcmp(debug_str, expected_debug_str) == 0);
}
@@ -107,20 +102,14 @@ static void test_template_node_to_debug_str(Arena *arena) {
static void test_template_section_node_to_debug_str(Arena *arena) {
// Create a section node with a child text node
TemplateNode *root = arena_alloc(arena, sizeof(TemplateNode));
root->type = TEMPLATE_NODE_SECTION;
root->value.section.iterator = arena_strncpy(arena, "item", 4);
root->value.section.collection = arena_strncpy(arena, "items", 5);
*root = init_template_node(arena, TEMPLATE_NODE_SECTION);
root->value->section.iterator = arena_strncpy(arena, "item", 4);
root->value->section.collection = arena_strncpy(arena, "items", 5);
// Create a body node (child of section)
root->value.section.body = arena_alloc(arena, sizeof(TemplateNode));
root->value.section.body->type = TEMPLATE_NODE_TEXT;
root->value.section.body->value.text.content = arena_strncpy(arena, "Loop content", 12);
// SAFETY(yukkop): if any of these are not NULL, the node will be corrupted
root->value.section.body->next = NULL;
root->value.section.body->children = NULL;
root->next = NULL;
root->children = NULL;
root->value->section.body = arena_alloc(arena, sizeof(TemplateNode));
*root->value->section.body = init_template_node(arena, TEMPLATE_NODE_TEXT);
root->value->section.body->value->text.content = arena_strncpy(arena, "Loop content", 12);
char *debug_str = debug_to_pretty_str(arena, TEMPLATE_NODE_TO_DEBUG_STR(arena, "root", root));
raise_log("debug_str: \n%s", debug_str);
@@ -134,14 +123,14 @@ static void test_template_section_node_to_debug_str(Arena *arena) {
char *expected_debug_str = arena_alloc(arena, MEM_KiB);
sprintf(expected_debug_str, TEST_TEMPLATE_SECTION_NODE_TO_DEBUG_STR,
(void*)root->value.section.iterator,
(void*)root->value.section.collection,
(void*)root->value.section.body->value.text.content,
(void*)&root->value.section.body->value.text,
(void*)&root->value.section.body->value,
(void*)root->value.section.body,
(void*)&root->value.section,
(void*)&root->value,
(void*)root->value->section.iterator,
(void*)root->value->section.collection,
(void*)root->value->section.body->value->text.content,
(void*)&root->value->section.body->value->text,
(void*)root->value->section.body->value,
(void*)root->value->section.body,
(void*)&root->value->section,
(void*)root->value,
(void*)root
);
@@ -150,6 +139,47 @@ static void test_template_section_node_to_debug_str(Arena *arena) {
assert(strcmp(debug_str, expected_debug_str) == 0);
}
static void simplest_test_template_parse(Arena *arena, TemplateConfig *config) {
const char *template_str = "{{ name }}";
TemplateResult template_result = template_parse(arena, &template_str, config);
if (IS_RESULT_ERROR(template_result)) {
raise_exception("template_parse failed");
return;
}
TemplateNode node = RESULT_SOME_VALUE(template_result);
{ // some debug output
Arena *debug_arena = DISPOSABLE_ARENA;
const char *json_str = TEMPLATE_NODE_TO_JSON_STR(debug_arena, &node);
Json *json = json_parse(debug_arena, &json_str);
raise_notice("json_str: \n%s", JSON_TO_PRETTY_STR(debug_arena, json));
}
}
static void simplest_interpolation_test_template_parse(Arena *arena, TemplateConfig *config) {
const char *template_str = "{% name %} {% name2 %}";
TemplateResult template_result = template_parse(arena, &template_str, config);
if (IS_RESULT_ERROR(template_result)) {
raise_exception("template_parse failed");
return;
}
TemplateNode node = RESULT_SOME_VALUE(template_result);
{ // some debug output
Arena *debug_arena = DISPOSABLE_ARENA;
const char *json_str = TEMPLATE_NODE_TO_JSON_STR(debug_arena, &node);
Json *json = json_parse(debug_arena, &json_str);
raise_log("json_str: \n%s", json_str);
raise_notice("json_str: \n%s", JSON_TO_PRETTY_STR(debug_arena, json));
}
}
int main(void) {
printf("%sRunning %s%s%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_CYAN), __FILE__, OPTIONAL_COLOR(COLOR_RESET));
debug_color_mode = COLOR_MODE_DISABLE;
@@ -157,8 +187,6 @@ int main(void) {
Arena arena = arena_init(ARENA_SIZE);
//TemplateConfig config = template_default_config();
printf("%sRunning template parser tests...%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_RESET));
test_template_node_to_debug_str(&arena);
@@ -169,11 +197,19 @@ int main(void) {
printf("%sTest 1: template_section_node_to_debug_str passed%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_RESET));
arena_reset(&arena);
//test_template_parse(&arena, &config);
//printf("%sTest 1: template_parse passed%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_RESET));
//arena_reset(&arena);
Arena config_arena = arena_init(ARENA_SIZE);
TemplateConfig config = template_default_config(&config_arena);
simplest_test_template_parse(&arena, &config);
printf("%sTest 2: simplest_test_template_parse passed%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_RESET));
arena_reset(&arena);
simplest_interpolation_test_template_parse(&arena, &config);
printf("%sTest 3: simplest_interpolation_test_template_parse passed%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_RESET));
arena_reset(&arena);
logger_free();
arena_free(&config_arena);
arena_free(&arena);
printf("%sall tests passed %s%s%s\n", OPTIONAL_COLOR(COLOR_GREEN), OPTIONAL_COLOR(COLOR_CYAN), __FILE__, OPTIONAL_COLOR(COLOR_RESET));
return 0;