ed/metadesk
1
0
Fork 0
mirror of https://github.com/Ed94/metadesk.git synced 2026-08-04 22:58:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

robustify against /W4 on MSVC

Browse Source
This commit is contained in:
ryanfleury
2022-02-17 14:14:50 -07:00
parent 7b2b00d8da
commit ecfe3314b6
7 changed files with 92 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/expression_tests.c
+30 -30
View File
@@ -3,7 +3,7 @@
#include "md.h"
#include "md.c"
MD_Arena *arena = 0;
MD_Arena *g_arena = 0;
typedef enum{
ExpressionErrorKind_Null,
@@ -233,7 +233,7 @@ static void reset_global_messages()
static void bake_operator_error_handler(MD_MessageKind kind, MD_String8 s)
{
// NOTE: Append error to global error list
MD_Message *message = MD_PushArrayZero(arena, MD_Message, 1);
MD_Message *message = MD_PushArrayZero(g_arena, MD_Message, 1);
message->kind = kind;
message->string = s;
MD_MessageListPush(&global_message_list, message);
@@ -249,7 +249,7 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
OPERATORS
#undef X
arena = MD_ArenaAlloc();
g_arena = MD_ArenaAlloc();
/* NOTE: Operator table bake errors */
{
@@ -259,79 +259,79 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
MD_String8 plus = MD_S8Lit("+");
MD_String8 minus = MD_S8Lit("-");
MD_String8 cast = MD_S8Lit("()");
MD_Node *plus_node = MD_MakeNode(arena, MD_NodeKind_Main, plus, plus, 0);
MD_Node *cast_node = MD_MakeNode(arena, MD_NodeKind_Main, cast, cast, 0);
MD_Node *minus_node = MD_MakeNode(arena, MD_NodeKind_Main, minus, minus, 0);
MD_Node *plus_node_bis = MD_MakeNode(arena, MD_NodeKind_Main, plus, plus, 0);
MD_Node *plus_node = MD_MakeNode(g_arena, MD_NodeKind_Main, plus, plus, 0);
MD_Node *cast_node = MD_MakeNode(g_arena, MD_NodeKind_Main, cast, cast, 0);
MD_Node *minus_node = MD_MakeNode(g_arena, MD_NodeKind_Main, minus, minus, 0);
MD_Node *plus_node_bis = MD_MakeNode(g_arena, MD_NodeKind_Main, plus, plus, 0);
MD_ExprSetBakeOperatorErrorHandler(bake_operator_error_handler);
// NOTE: Wrong operator kind
reset_global_messages();
operator_list = (MD_ExprOprList){0};
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Null, 1, MD_S8Lit("+"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Null, 1, MD_S8Lit("+"),
Op_Addition, plus_node);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning &&
global_message_list.node_count == 1);
// NOTE: () not as unary postfix
operator_list = (MD_ExprOprList){0};
reset_global_messages();
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Prefix, 1, MD_S8Lit("()"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Prefix, 1, MD_S8Lit("()"),
23 /* arbitrary MD_ExprOprKind */, cast_node);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning &&
global_message_list.node_count == 1);
// NOTE: Repeat operator
operator_list = (MD_ExprOprList){0};
reset_global_messages();
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
Op_Addition, plus_node);
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
Op_Addition, plus_node_bis);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning &&
global_message_list.node_count == 1);
operator_list = (MD_ExprOprList){0};
reset_global_messages();
// NOTE: Binary-postfix operator conflict
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
Op_Addition, plus_node);
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Postfix, 1, MD_S8Lit("+"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Postfix, 1, MD_S8Lit("+"),
Op_Addition, plus_node_bis);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning
&& global_message_list.node_count == 1);
operator_list = (MD_ExprOprList){0};
reset_global_messages();
// NOTE: Same precedence difference associativity conflict
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Binary, 1, MD_S8Lit("+"),
Op_Addition, plus_node);
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_BinaryRightAssociative, 1, MD_S8Lit("-"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_BinaryRightAssociative, 1, MD_S8Lit("-"),
Op_Addition, minus_node);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning &&
global_message_list.node_count == 1);
// NOTE: Multitoken operator
reset_global_messages();
operator_list = (MD_ExprOprList){0};
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Prefix, 1, MD_S8Lit("+ +"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Prefix, 1, MD_S8Lit("+ +"),
23 /* arbitrary MD_ExprOprKind */, plus_node);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning &&
global_message_list.node_count == 1);
// NOTE: Wrong token kind operator
reset_global_messages();
operator_list = (MD_ExprOprList){0};
MD_ExprOprPush(arena, &operator_list, MD_ExprOprKind_Prefix, 1, MD_S8Lit("123"),
MD_ExprOprPush(g_arena, &operator_list, MD_ExprOprKind_Prefix, 1, MD_S8Lit("123"),
23 /* arbitrary MD_ExprOprKind */, plus_node);
op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
MD_Assert(global_max_message_kind == MD_MessageKind_Warning &&
global_message_list.node_count == 1);
}
@@ -341,12 +341,12 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
for(Op op = Op_Null+1; op < Op_COUNT; ++op)
{
OperatorDescription *desc = operator_array + op;
MD_Node *node = MD_MakeNode(arena, MD_NodeKind_Main, desc->s, desc->s, 0);
MD_ExprOprPush(arena, &operator_list, desc->op.kind, desc->op.precedence, desc->s,
MD_Node *node = MD_MakeNode(g_arena, MD_NodeKind_Main, desc->s, desc->s, 0);
MD_ExprOprPush(g_arena, &operator_list, desc->op.kind, desc->op.precedence, desc->s,
op, node);
}
MD_ExprOprTable op_table = MD_ExprBakeOprTableFromList(arena, &operator_list);
MD_ExprOprTable op_table = MD_ExprBakeOprTableFromList(g_arena, &operator_list);
// NOTE(mal): I'm trying something different for expression parser tests. Normally one would take the
// output of MD_ExprParse and compare it against the expected output expression tree.
@@ -417,13 +417,13 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
MD_String8 q = MD_S8CString(test.q);
MD_String8 a = MD_S8CString(test.a);
MD_ParseResult parse = MD_ParseWholeString(arena, MD_S8Lit("test"), q);
MD_ParseResult parse = MD_ParseWholeString(g_arena, MD_S8Lit("test"), q);
if(parse.errors.max_message_kind == MD_MessageKind_Null)
{
MD_ExprParseResult expr_parse = MD_ExprParse(arena, &op_table, parse.node->first_child, MD_NilNode());
MD_ExprParseResult expr_parse = MD_ExprParse(g_arena, &op_table, parse.node->first_child, MD_NilNode());
if(expr_parse.errors.max_message_kind == MD_MessageKind_Null)
{
MD_String8 parser_answer = parenthesize(arena, operator_array, expr_parse.expr);
MD_String8 parser_answer = parenthesize(g_arena, operator_array, expr_parse.expr);
if(!MD_S8Match(parser_answer, a, 0))
{
printf("Example %d : Expected answer for %.*s is %.*s. Got %.*s\n",
tests/sanity_tests.c
+26 -26
View File
@@ -15,13 +15,13 @@ test_ctx;
static void
BeginTest(char *name)
{
int length = MD_CalculateCStringLength(name);
int spaces = 25 - length;
MD_u64 length = MD_CalculateCStringLength(name);
MD_u64 spaces = 25 - length;
if(spaces < 0)
{
spaces = 0;
}
printf("\"%s\" %.*s [", name, spaces, "------------------------------");
printf("\"%s\" %.*s [", name, (int)spaces, "------------------------------");
test_ctx.number_of_tests = 0;
test_ctx.number_passed = 0;
}
@@ -389,7 +389,7 @@ int main(void)
Test("Errors")
{
struct { char *s; int columns[2]; } tests[] = {
struct { char *s; MD_u64 columns[2]; } tests[] = {
{"{", {1}},
{"}", {1}},
{"'", {1}},
@@ -438,9 +438,9 @@ int main(void)
{
MD_String8 key_strings[] =
{
MD_S8Lit("\xed\x80\x73\x71\x78\xba\xff\xd6\x87\x83\xcd\x20\x28\xf7\x1c\xc1\x5f\xca\x98\x9c\x5a\xab\x0c\xae\x9a\x60\x57\x03\xeb\x1f\xde\x99"),
MD_S8Lit("\x4c\x80\xb7\x8b\xbf\x65\x5a\x4b\xc1\x2a\xc3\x5f\xe1\x66\xfb\x0d\x72\x83\x1c\x63\xba\xb5\x97\x02\x3f\x6a\xe0\x2a\x1b\x82\x07\x76"),
MD_S8Lit("\xd8\xfd\x11\x4b\x04\xdf\xe5\x20\x5b\xd6\x4f\x87\x00\x70\x6a\xc8\xde\xed\xc7\x79\xdb\x87\x24\x36\xa8\x7a\x31\x41\x00\x57\xbd\x8d"),
MD_S8LitComp("\xed\x80\x73\x71\x78\xba\xff\xd6\x87\x83\xcd\x20\x28\xf7\x1c\xc1\x5f\xca\x98\x9c\x5a\xab\x0c\xae\x9a\x60\x57\x03\xeb\x1f\xde\x99"),
MD_S8LitComp("\x4c\x80\xb7\x8b\xbf\x65\x5a\x4b\xc1\x2a\xc3\x5f\xe1\x66\xfb\x0d\x72\x83\x1c\x63\xba\xb5\x97\x02\x3f\x6a\xe0\x2a\x1b\x82\x07\x76"),
MD_S8LitComp("\xd8\xfd\x11\x4b\x04\xdf\xe5\x20\x5b\xd6\x4f\x87\x00\x70\x6a\xc8\xde\xed\xc7\x79\xdb\x87\x24\x36\xa8\x7a\x31\x41\x00\x57\xbd\x8d"),
};
MD_MapKey keys[MD_ArrayCount(key_strings)*2];
@@ -479,12 +479,12 @@ int main(void)
Test("String Inner & Outer")
{
MD_String8 samples[6] = {
MD_S8Lit("'foo-bar'"),
MD_S8Lit("'''foo-bar'''"),
MD_S8Lit("\"foo-bar\""),
MD_S8Lit("\"\"\"foo-bar\"\"\""),
MD_S8Lit("`foo-bar`"),
MD_S8Lit("```foo-bar```"),
MD_S8LitComp("'foo-bar'"),
MD_S8LitComp("'''foo-bar'''"),
MD_S8LitComp("\"foo-bar\""),
MD_S8LitComp("\"\"\"foo-bar\"\"\""),
MD_S8LitComp("`foo-bar`"),
MD_S8LitComp("```foo-bar```"),
};
MD_Node *nodes[MD_ArrayCount(samples)];
@@ -716,10 +716,10 @@ int main(void)
MD_String8 file_name = MD_S8Lit("raw_text");
MD_String8 test_strings[] = {
MD_S8Lit("0765"),
MD_S8Lit("0xABC"),
MD_S8Lit("0x123"),
MD_S8Lit("0b010"),
MD_S8LitComp("0765"),
MD_S8LitComp("0xABC"),
MD_S8LitComp("0x123"),
MD_S8LitComp("0b010"),
};
MD_String8 *string = test_strings;
@@ -737,15 +737,15 @@ int main(void)
MD_String8 file_name = MD_S8Lit("raw_text");
MD_String8 test_strings[] = {
MD_S8Lit("0"),
MD_S8Lit("1"),
MD_S8Lit("0.5"),
MD_S8Lit("1e2"),
MD_S8Lit("1e+2"),
MD_S8Lit("1e-2"),
MD_S8Lit("1.5e2"),
MD_S8Lit("1.5e+2"),
MD_S8Lit("1.5e-2"),
MD_S8LitComp("0"),
MD_S8LitComp("1"),
MD_S8LitComp("0.5"),
MD_S8LitComp("1e2"),
MD_S8LitComp("1e+2"),
MD_S8LitComp("1e-2"),
MD_S8LitComp("1.5e2"),
MD_S8LitComp("1.5e+2"),
MD_S8LitComp("1.5e-2"),
};
MD_String8 *string = test_strings;
tests/unicode_test.c
+1 -1
View File
@@ -21,7 +21,7 @@ int main(void)
// TODO(allen): throw more at this.
char test_string_c[] = "Foo bar; test the unicode\n\t\0Etc";
MD_String8 test_string = MD_S8(test_string_c, sizeof(test_string_c) - 1);
MD_String8 test_string = MD_S8((MD_u8 *)test_string_c, sizeof(test_string_c) - 1);
run_test_on_string(test_string);