/**
* mds — A micro-display server
* Copyright © 2014 Mattias Andrée (maandree@member.fsf.org)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "validate-tree.h"
#include <stdlib.h>
#include <errno.h>
/**
* Tree type constant shortener
*/
#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE
/**
* Add an error to the error list
*
* @param NODE:const mds_kbdc_tree_t* The node the triggered the error
* @param SEVERITY:identifier * in `MDS_KBDC_PARSE_ERROR_*` to indicate severity
* @param ...:const char*, ... Error description format string and arguments
* @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored
*/
#define NEW_ERROR(NODE, SEVERITY, ...) \
NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line, \
(NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__)
/**
* Add “included from here”-notes
*
* @param PTR:size_t The number of “included from here”-notes
*/
#define DUMP_INCLUDE_STACK(PTR) \
fail_if (dump_include_stack(PTR))
/**
* Add an error with “included from here”-notes to the error list
*
* @param NODE:const mds_kbdc_tree_t* The node the triggered the error
* @param PTR:size_t The number of “included from here”-notes
* @param SEVERITY:identifier * in `MDS_KBDC_PARSE_ERROR_*` to indicate severity
* @param ...:const char*, ... Error description format string and arguments
* @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored
*/
#define NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, ...) \
do \
{ \
NEW_ERROR(NODE, SEVERITY, __VA_ARGS__); \
DUMP_INCLUDE_STACK(PTR); \
} \
while (0)
/**
* Variable whether the latest created error is stored
*/
static mds_kbdc_parse_error_t* error;
/**
* The parameter of `process_includes`
*/
static mds_kbdc_parsed_t* restrict result;
/**
* Stack of visited include-statements
*/
static mds_kbdc_tree_include_t** restrict includes = NULL;
/**
* The number elements allocated for `includes`
*/
static size_t includes_size = 0;
/**
* The number elements stored in `includes`
*/
static size_t includes_ptr = 0;
/**
* Stack of visited for-statements
*/
static mds_kbdc_tree_for_t** restrict fors = NULL;
/**
* The number elements allocated for `fors`
*/
static size_t fors_size = 0;
/**
* The number elements stored in `fors`
*/
static size_t fors_ptr = 0;
/**
* The function definition that is currently being visited
*/
static mds_kbdc_tree_function_t* function = NULL;
/**
* The macro definition that is currently being visited
*/
static mds_kbdc_tree_macro_t* macro = NULL;
/**
* The information clause that is currently being visited
*/
static mds_kbdc_tree_information_t* information = NULL;
/**
* The assumption clause that is currently being visited
*/
static mds_kbdc_tree_assumption_t* assumption = NULL;
/**
* The value `includes_ptr` had when `function`,
* `macro`, `information` or `assumption` was set
*/
static size_t def_includes_ptr = 0;
/**
* Validate that a part of the structure of the compilation unit
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_subtree(mds_kbdc_tree_t* restrict tree);
/**
* Add “included from here”-notes
*
* @param ptr The number of “included from here”-notes
* @return Zero on success, -1 on error
*/
static int dump_include_stack(size_t ptr)
{
while (ptr--)
NEW_ERROR(includes[ptr], NOTE, "included from here");
return 0;
pfail:
return -1;
}
/**
* Validate an include-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_include(mds_kbdc_tree_include_t* restrict tree)
{
mds_kbdc_tree_include_t** old;
int r, saved_errno;
if (includes_ptr == includes_size)
if (xxrealloc(old, includes, includes_size += 4, mds_kbdc_tree_include_t*))
return saved_errno = errno, free(old), errno = saved_errno, -1;
includes[includes_ptr++] = tree;
r = validate_subtree(tree->inner);
return includes_ptr--, r;
}
/**
* Validate a function definition
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_function(mds_kbdc_tree_function_t* restrict tree)
{
int r;
if (function)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "nested function definition");
NEW_ERROR_WITH_INCLUDES(function, def_includes_ptr, NOTE, "outer function defined here");
return 0;
}
else if (macro)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "function definition inside macro definition");
NEW_ERROR_WITH_INCLUDES(macro, def_includes_ptr, NOTE, "outer macro defined here");
return 0;
}
else if (information)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "function definition inside information clause");
NEW_ERROR_WITH_INCLUDES(information, def_includes_ptr, NOTE, "outer information clause defined here");
return 0;
}
else if (assumption)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "function definition inside assumption clause");
NEW_ERROR_WITH_INCLUDES(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here");
return 0;
}
function = tree;
def_includes_ptr = includes_ptr;
r = validate_subtree(tree->inner);
return function = NULL, r;
pfail:
return -1;
}
/**
* Validate a macro definition
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_macro(mds_kbdc_tree_macro_t* restrict tree)
{
int r;
if (function)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "macro definition inside function definition");
NEW_ERROR_WITH_INCLUDES(function, def_includes_ptr, NOTE, "outer function definition defined here");
return 0;
}
else if (macro)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "nested macro definition");
NEW_ERROR_WITH_INCLUDES(macro, def_includes_ptr, NOTE, "outer macro defined here");
return 0;
}
else if (information)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "macro definition inside information clause");
NEW_ERROR_WITH_INCLUDES(information, def_includes_ptr, NOTE, "outer information clause defined here");
return 0;
}
else if (assumption)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "macro definition inside assumption clause");
NEW_ERROR_WITH_INCLUDES(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here");
return 0;
}
macro = tree;
def_includes_ptr = includes_ptr;
r = validate_subtree(tree->inner);
return macro = NULL, r;
pfail:
return -1;
}
/**
* Validate an information clause
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_information(mds_kbdc_tree_information_t* restrict tree)
{
int r;
if (function)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "information clause inside function definition");
NEW_ERROR_WITH_INCLUDES(function, def_includes_ptr, NOTE, "outer function definition defined here");
return 0;
}
else if (macro)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "information clause inside macro definition");
NEW_ERROR_WITH_INCLUDES(macro, def_includes_ptr, NOTE, "outer macro defined here");
return 0;
}
else if (information)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "nested information clause");
NEW_ERROR_WITH_INCLUDES(information, def_includes_ptr, NOTE, "outer information clause defined here");
return 0;
}
else if (assumption)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "information clause inside assumption clause");
NEW_ERROR_WITH_INCLUDES(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here");
return 0;
}
information = tree;
def_includes_ptr = includes_ptr;
r = validate_subtree(tree->inner);
return information = NULL, r;
pfail:
return -1;
}
/**
* Validate an assumption clause
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_assumption(mds_kbdc_tree_assumption_t* restrict tree)
{
int r;
if (function)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "assumption clause inside function definition");
NEW_ERROR_WITH_INCLUDES(function, def_includes_ptr, NOTE, "outer function definition defined here");
return 0;
}
else if (macro)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "assumption clause inside macro definition");
NEW_ERROR_WITH_INCLUDES(macro, def_includes_ptr, NOTE, "outer macro defined here");
return 0;
}
else if (information)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "assumption clause inside information clause");
NEW_ERROR_WITH_INCLUDES(information, def_includes_ptr, NOTE, "outer information clause defined here");
return 0;
}
else if (assumption)
{
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "nested assumption clause");
NEW_ERROR_WITH_INCLUDES(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here");
return 0;
}
information = tree;
def_includes_ptr = includes_ptr;
r = validate_subtree(tree->inner);
return information = NULL, r;
pfail:
return -1;
}
/**
* Validate a mapping- or value-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_map(mds_kbdc_tree_map_t* restrict tree)
{
int is_value = tree->result == NULL;
if (information && is_value)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "value-statement inside information clause");
else if (information)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "mapping-statement inside information clause");
else if (assumption && is_value)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "value-statement inside assumption clause");
else if (assumption)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "mapping-statement inside assumption clause");
else if (function && !is_value)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "mapping-statement inside function definition");
else if ((function == NULL) && is_value)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "value-statement outside function definition");
/* FIXME \set outside function definition must be supported (warn if inside quotes) */
return 0;
pfail:
return -1;
}
/**
* Validate a macro call
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_macro_call(mds_kbdc_tree_macro_call_t* restrict tree)
{
if (information)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "macro call inside information clause");
else if (assumption)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "macro call inside assumption clause");
else if (function)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "macro call inside function definition");
return 0;
pfail:
return -1;
}
/**
* Validate a for-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_for(mds_kbdc_tree_for_t* restrict tree)
{
mds_kbdc_tree_for_t** old;
int r, saved_errno;
if (fors_ptr == fors_size)
if (xxrealloc(old, fors, fors_size += 4, mds_kbdc_tree_for_t*))
return saved_errno = errno, free(old), errno = saved_errno, -1;
fors[fors_ptr++] = tree;
r = validate_subtree(tree->inner);
return fors_ptr--, r;
}
/**
* Validate a if-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_if(mds_kbdc_tree_if_t* restrict tree)
{
return -(validate_subtree(tree->inner) ||
validate_subtree(tree->otherwise));
}
/**
* Validate a return-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_return(mds_kbdc_tree_return_t* restrict tree)
{
if ((function == NULL) && (macro == NULL))
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "‘return’ outside function and macro definition");
return 0;
pfail:
return -1;
}
/**
* Validate a break-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_break(mds_kbdc_tree_break_t* restrict tree)
{
if (fors_ptr == 0)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "‘break’ outside ‘for’");
return 0;
pfail:
return -1;
}
/**
* Validate a continue-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_continue(mds_kbdc_tree_continue_t* restrict tree)
{
if (fors_ptr == 0)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "‘continue’ outside ‘for’");
return 0;
pfail:
return -1;
}
/**
* Validate an assumption-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_assumption_data(mds_kbdc_tree_t* restrict tree)
{
if (assumption == NULL)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "assumption outside assumption clause");
return 0;
pfail:
return -1;
}
/**
* Validate an information-statement
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_information_data(mds_kbdc_tree_t* restrict tree)
{
if (information == NULL)
NEW_ERROR_WITH_INCLUDES(tree, includes_ptr, ERROR, "information outside information clause");
return 0;
pfail:
return -1;
}
/**
* Validate that a part of the structure of the compilation unit
*
* @param tree The tree to validate
* @return Zero on success, -1 on error
*/
static int validate_subtree(mds_kbdc_tree_t* restrict tree)
{
#define v(type) if ((r = validate_##type(&(tree->type)))) return r
#define V(type) if ((r = validate_##type(&(tree->type##_)))) return r
int r;
again:
if (tree == NULL)
return 0;
switch (tree->type)
{
case C(INFORMATION): v(information); break;
case C(INCLUDE): v(include); break;
case C(FUNCTION): v(function); break;
case C(MACRO): v(macro); break;
case C(ASSUMPTION): v(assumption); break;
case C(FOR): V(for); break;
case C(IF): V(if); break;
case C(MAP): v(map); break;
case C(MACRO_CALL): v(macro_call); break;
case C(RETURN): V(return); break;
case C(BREAK): V(break); break;
case C(CONTINUE): V(continue); break;
case C(INFORMATION_LANGUAGE):
case C(INFORMATION_COUNTRY):
case C(INFORMATION_VARIANT):
if ((r = validate_information_data(tree)))
return r;
break;
case C(ASSUMPTION_HAVE):
case C(ASSUMPTION_HAVE_CHARS):
case C(ASSUMPTION_HAVE_RANGE):
if ((r = validate_assumption_data(tree)))
return r;
break;
default:
break;
}
tree = tree->next;
goto again;
#undef V
#undef v
}
/**
* Validate that the structure of the compilation unit
*
* @param result_ `result` from `process_includes`, will be updated
* @return -1 if an error occursed that cannot be stored in `result`, zero otherwise
*/
int validate_tree(mds_kbdc_parsed_t* restrict result_)
{
int r, saved_errno;
result = result_;
r = validate_subtree(result_->tree);
saved_errno = errno;
free(includes), includes = NULL, includes_size = includes_ptr = 0;
free(fors), fors = NULL, fors_size = fors_ptr = 0;
return errno = saved_errno, r;
}
#undef NEW_ERROR_WITH_INCLUDES
#undef DUMP_INCLUDE_STACK
#undef NEW_ERROR
#undef C
