mirror of
https://github.com/Ed94/metadesk.git
synced 2026-06-13 07:52:22 -07:00
clean house on old examples; sketch out outline for new examples
This commit is contained in:
Allen Webster
@@ -10,8 +10,6 @@ echo "~~~ Build All Exampes ~~~"
|
||||
bin/bld_core.sh show_ctx
|
||||
|
||||
bin/bld_core.sh unit old_style_custom_layer examples/old_style_custom_layer.c
|
||||
bin/bld_core.sh unit output_parse examples/output_parse/output_parse.c
|
||||
bin/bld_core.sh unit c_code_generation examples/c_code_generation.c
|
||||
bin/bld_core.sh unit node_errors examples/node_errors/node_errors.c
|
||||
bin/bld_core.sh unit parse_check examples/parse_check.c
|
||||
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
###### Get Paths ##############################################################
|
||||
og_path=$PWD
|
||||
cd "$(dirname "$0")"
|
||||
cd ..
|
||||
|
||||
###### Script #################################################################
|
||||
echo "~~~ Build All Exampes ~~~"
|
||||
bin/bld_core.sh show_ctx
|
||||
|
||||
bin/bld_core.sh unit old_style_custom_layer examples/old_style_custom_layer.c
|
||||
bin/bld_core.sh unit output_parse examples/output_parse/output_parse.c
|
||||
bin/bld_core.sh unit c_code_generation examples/c_code_generation.c
|
||||
bin/bld_core.sh unit node_errors examples/node_errors/node_errors.c
|
||||
bin/bld_core.sh unit parse_check examples/parse_check.c
|
||||
|
||||
echo
|
||||
|
||||
###### Restore Path ###########################################################
|
||||
cd $og_path
|
||||
@@ -18,11 +18,6 @@ if [ -d "output_parse/examples" ]; then
|
||||
fi
|
||||
echo
|
||||
|
||||
echo ~~~ Running C Code Generation Example ~~~
|
||||
cd $build_path
|
||||
./c_code_generation.exe
|
||||
echo
|
||||
|
||||
echo ~~~ Running Error Generation Example ~~~
|
||||
cd $build_path
|
||||
./node_errors.exe $examples_path/node_errors/node_errors.mdesk
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
###### Get Paths ##############################################################
|
||||
og_path=$PWD
|
||||
cd "$(dirname "$0")"
|
||||
cd ..
|
||||
root_path=$PWD
|
||||
build_path=$root_path/build
|
||||
examples_path=$root_path/examples
|
||||
|
||||
echo ~~~ Running Output Parse Example ~~~
|
||||
cd $examples_path
|
||||
if [ -d "output_parse/examples" ]; then
|
||||
cd output_parse/examples
|
||||
mkdir -p output
|
||||
cd output
|
||||
$build_path/output_parse.exe ../example.mdesk ../example2.mdesk
|
||||
fi
|
||||
echo
|
||||
|
||||
echo ~~~ Running C Code Generation Example ~~~
|
||||
cd $build_path
|
||||
./c_code_generation.exe
|
||||
echo
|
||||
|
||||
echo ~~~ Running Error Generation Example ~~~
|
||||
cd $build_path
|
||||
./node_errors.exe $examples_path/node_errors/node_errors.mdesk
|
||||
echo
|
||||
|
||||
echo ~~~ Running C++ Example ~~~
|
||||
cd $build_path
|
||||
./cpp_build_test.exe
|
||||
echo
|
||||
|
||||
###### Restore Path ###########################################################
|
||||
cd $og_path
|
||||
@@ -1,42 +0,0 @@
|
||||
// Sample program that takes C-like information specified in the Metadesk format
|
||||
// and generates valid C code from it.
|
||||
|
||||
#include "md.h"
|
||||
#include "md_c_helpers.h"
|
||||
|
||||
#include "md.c"
|
||||
#include "md_c_helpers.c"
|
||||
|
||||
static MD_Arena *arena = 0;
|
||||
|
||||
int main(int argument_count, char **arguments)
|
||||
{
|
||||
arena = MD_ArenaAlloc(1ull << 40);
|
||||
|
||||
MD_String8 example_code = MD_S8Lit("@struct Foo:\n"
|
||||
"{\n"
|
||||
" a: S32,\n"
|
||||
" b: *S32,\n"
|
||||
" c: **void,\n"
|
||||
" d: F32,\n"
|
||||
" e: *[100]F32,\n"
|
||||
" f: ([4 + 5]S32),\n"
|
||||
" g: ([FOO + BAR]I32),\n"
|
||||
"}\n\n");
|
||||
MD_Node *code = MD_ParseWholeString(arena, MD_S8Lit("Generated Test Code"), example_code).node;
|
||||
|
||||
printf("Source Metadesk Code:\n");
|
||||
printf("%.*s\n\n", MD_S8VArg(example_code));
|
||||
|
||||
printf("Generated C Code:\n");
|
||||
for(MD_EachNode(node, code->first_child))
|
||||
{
|
||||
if(MD_NodeHasTag(node, MD_S8Lit("struct"), 0))
|
||||
{
|
||||
MD_C_Generate_Struct(stdout, node);
|
||||
}
|
||||
}
|
||||
printf("\n\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <assert.h>
|
||||
#include "generated/converter.c"
|
||||
|
||||
int main(void)
|
||||
{
|
||||
v1_Entry v1_entry = {0};
|
||||
|
||||
v1_entry.to_remove = 12;
|
||||
|
||||
v1_entry.kind = v1_EntryKind_C;
|
||||
|
||||
v1_entry.flags = v1_EntryFlag_B | v1_EntryFlag_C;
|
||||
|
||||
v1_entry.color.components.r = 255;
|
||||
v1_entry.color.components.g = 128;
|
||||
v1_entry.color.components.b = 1;
|
||||
v1_entry.color.components.a = 42;
|
||||
|
||||
v1_entry.p.x = 2;
|
||||
v1_entry.p.y = 3;
|
||||
|
||||
Entry entry = EntryFromV1(v1_entry);
|
||||
|
||||
assert(entry.kind == EntryKind_C);
|
||||
assert(entry.flags == (EntryFlag_B | EntryFlag_C));
|
||||
assert(entry.color.components.r == 255);
|
||||
assert(entry.color.components.g == 128);
|
||||
assert(entry.color.components.b == 1);
|
||||
assert(entry.color.components.a == 42);
|
||||
assert(v1_entry.p.x == 2);
|
||||
assert(v1_entry.p.y == 3);
|
||||
|
||||
printf("Conversion test success!\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
// V1
|
||||
typedef enum
|
||||
{
|
||||
v1_EntryKind_A,
|
||||
v1_EntryKind_B,
|
||||
v1_EntryKind_C,
|
||||
v1_EntryKind_E,
|
||||
} v1_EntryKind;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
v1_EntryFlag_A = (1<<0),
|
||||
v1_EntryFlag_B = (1<<1),
|
||||
v1_EntryFlag_C = (1<<2),
|
||||
} v1_EntryFlags;
|
||||
|
||||
typedef union v1_Color v1_Color;
|
||||
union v1_Color
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint8_t r;
|
||||
uint8_t g;
|
||||
uint8_t b;
|
||||
uint8_t a;
|
||||
} components;
|
||||
uint8_t raw[4];
|
||||
};
|
||||
|
||||
typedef struct v1_Entry v1_Entry;
|
||||
struct v1_Entry
|
||||
{
|
||||
uint16_t to_remove;
|
||||
v1_EntryKind kind;
|
||||
v1_EntryFlags flags;
|
||||
v1_Color color;
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
} p;
|
||||
};
|
||||
|
||||
// V2
|
||||
typedef enum
|
||||
{
|
||||
EntryKind_A,
|
||||
EntryKind_B,
|
||||
EntryKind_B2,
|
||||
EntryKind_C,
|
||||
} EntryKind;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
EntryFlag_B = (1<<0),
|
||||
EntryFlag_C = (1<<1),
|
||||
EntryFlag_D = (1<<2),
|
||||
} EntryFlags;
|
||||
|
||||
typedef union Color Color;
|
||||
union Color
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint8_t b;
|
||||
uint8_t g;
|
||||
uint8_t r;
|
||||
uint8_t a;
|
||||
} components;
|
||||
uint8_t raw[4];
|
||||
};
|
||||
|
||||
typedef struct Entry Entry;
|
||||
struct Entry
|
||||
{
|
||||
EntryKind kind;
|
||||
Color color;
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
} p;
|
||||
EntryFlags flags;
|
||||
};
|
||||
|
||||
// V1->V2
|
||||
static EntryKind EntryKindFromV1(v1_EntryKind v)
|
||||
{
|
||||
EntryKind result = 0;
|
||||
switch(v)
|
||||
{
|
||||
case v1_EntryKind_A: result = EntryKind_A; break;
|
||||
case v1_EntryKind_B: result = EntryKind_B; break;
|
||||
case v1_EntryKind_C: result = EntryKind_C; break;
|
||||
case v1_EntryKind_E: assert(!"Enumerand v1_EntryKind_E is no longer allowed\n");
|
||||
default: assert(!"Illegal value for enum v1_EntryKind\n"); break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static EntryFlags EntryFlagsFromV1(v1_EntryFlags v)
|
||||
{
|
||||
EntryFlags result = 0;
|
||||
if(v & v1_EntryFlag_A) assert(!"Flag v1_A is no longer allowed\n");
|
||||
if(v & v1_EntryFlag_B) result |= EntryFlag_B;
|
||||
if(v & v1_EntryFlag_C) result |= EntryFlag_C;
|
||||
return result;
|
||||
}
|
||||
|
||||
static Color ColorFromV1(v1_Color v)
|
||||
{
|
||||
Color result = {0};
|
||||
result.components.r = v.components.r;
|
||||
result.components.g = v.components.g;
|
||||
result.components.b = v.components.b;
|
||||
result.components.a = v.components.a;
|
||||
return result;
|
||||
}
|
||||
|
||||
static Entry EntryFromV1(v1_Entry v)
|
||||
{
|
||||
Entry result = {0};
|
||||
result.kind = EntryKindFromV1(v.kind);
|
||||
result.color = ColorFromV1(v.color);
|
||||
result.p.x = v.p.x;
|
||||
result.p.y = v.p.y;
|
||||
result.flags = EntryFlagsFromV1(v.flags);
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
@struct foo : {
|
||||
x : ([MAX_PATH]char),
|
||||
}
|
||||
|
||||
@struct @test_tag bar : {
|
||||
y : float,
|
||||
z: i32,
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
@sets a_set : {
|
||||
named_set : {1, 3, 7},
|
||||
{not, named, set},
|
||||
@tag_with_params(p1, p2, p3) { e1, e2, e3 },
|
||||
@tag_with_params(p1, p2, p3) @tag2_with_params(p, pp, ppp) { e1, e2, e3 },
|
||||
}
|
||||
|
||||
@empty_set empty : {
|
||||
}
|
||||
|
||||
@tagged_unnamed_set {
|
||||
a_label: {unnamed_set_element}
|
||||
}
|
||||
|
||||
@showcase_mixed_set_scoping {
|
||||
@symbol_label
|
||||
+: (1 2 3],
|
||||
@symbol_label
|
||||
*: [x y z),
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, Identifier,
|
||||
String: foo,
|
||||
Whole String: foo,
|
||||
Tag: @struct
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 1100000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasParenLeft, HasParenRight, IsBeforeComma, Identifier,
|
||||
String: x,
|
||||
Whole String: x,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0011000000000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBracketLeft, HasBracketRight,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: MAX_PATH,
|
||||
Whole String: MAX_PATH,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: char,
|
||||
Whole String: char,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, Identifier,
|
||||
String: bar,
|
||||
Whole String: bar,
|
||||
Tag: @struct
|
||||
Tag: @test_tag
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: y,
|
||||
Whole String: y,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: float,
|
||||
Whole String: float,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: z,
|
||||
Whole String: z,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: i32,
|
||||
Whole String: i32,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,282 +0,0 @@
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, Identifier,
|
||||
String: a_set,
|
||||
Whole String: a_set,
|
||||
Tag: @sets
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, Identifier,
|
||||
String: named_set,
|
||||
Whole String: named_set,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000010000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Numeric,
|
||||
String: 1,
|
||||
Whole String: 1,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000010000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Numeric,
|
||||
String: 3,
|
||||
Whole String: 3,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000010000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Numeric,
|
||||
String: 7,
|
||||
Whole String: 7,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110011000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, IsAfterComma,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Identifier,
|
||||
String: not,
|
||||
Whole String: not,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Identifier,
|
||||
String: named,
|
||||
Whole String: named,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Identifier,
|
||||
String: set,
|
||||
Whole String: set,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110011000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, IsAfterComma,
|
||||
Tag: @tag_with_params
|
||||
Tag Children{
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Identifier,
|
||||
String: p1,
|
||||
Whole String: p1,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Identifier,
|
||||
String: p2,
|
||||
Whole String: p2,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Identifier,
|
||||
String: p3,
|
||||
Whole String: p3,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Identifier,
|
||||
String: e1,
|
||||
Whole String: e1,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Identifier,
|
||||
String: e2,
|
||||
Whole String: e2,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Identifier,
|
||||
String: e3,
|
||||
Whole String: e3,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110011000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, IsBeforeComma, IsAfterComma,
|
||||
Tag: @tag_with_params
|
||||
Tag Children{
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Identifier,
|
||||
String: p1,
|
||||
Whole String: p1,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Identifier,
|
||||
String: p2,
|
||||
Whole String: p2,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Identifier,
|
||||
String: p3,
|
||||
Whole String: p3,
|
||||
}
|
||||
}
|
||||
Tag: @tag2_with_params
|
||||
Tag Children{
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Identifier,
|
||||
String: p,
|
||||
Whole String: p,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Identifier,
|
||||
String: pp,
|
||||
Whole String: pp,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Identifier,
|
||||
String: ppp,
|
||||
Whole String: ppp,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000010000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, Identifier,
|
||||
String: e1,
|
||||
Whole String: e1,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000011000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsBeforeComma, IsAfterComma, Identifier,
|
||||
String: e2,
|
||||
Whole String: e2,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000001000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: IsAfterComma, Identifier,
|
||||
String: e3,
|
||||
Whole String: e3,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, Identifier,
|
||||
String: empty,
|
||||
Whole String: empty,
|
||||
Tag: @empty_set
|
||||
}
|
||||
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight,
|
||||
Tag: @tagged_unnamed_set
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight, Identifier,
|
||||
String: a_label,
|
||||
Whole String: a_label,
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: unnamed_set_element,
|
||||
Whole String: unnamed_set_element,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000110000000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasBraceLeft, HasBraceRight,
|
||||
Tag: @showcase_mixed_set_scoping
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 1001000010000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasParenLeft, HasBracketRight, IsBeforeComma,
|
||||
String: +,
|
||||
Whole String: +,
|
||||
Tag: @symbol_label
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000010000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Numeric,
|
||||
String: 1,
|
||||
Whole String: 1,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000010000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Numeric,
|
||||
String: 2,
|
||||
Whole String: 2,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000010000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Numeric,
|
||||
String: 3,
|
||||
Whole String: 3,
|
||||
}
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0110000011000000000000000000000000000000000000000000000000000000,
|
||||
Flag Names: HasParenRight, HasBracketLeft, IsBeforeComma, IsAfterComma,
|
||||
String: *,
|
||||
Whole String: *,
|
||||
Tag: @symbol_label
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: x,
|
||||
Whole String: x,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: y,
|
||||
Whole String: y,
|
||||
}
|
||||
Node {
|
||||
Kind: Main,
|
||||
Flags: 0000000000000001000000000000000000000000000000000000000000000000,
|
||||
Flag Names: Identifier,
|
||||
String: z,
|
||||
Whole String: z,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,94 +0,0 @@
|
||||
// Sample code to print out the data from MD_ParseWholeFile
|
||||
#include "md.h"
|
||||
#include "md.c"
|
||||
|
||||
static MD_Arena *arena = 0;
|
||||
|
||||
#define INDENT_SPACES 2
|
||||
static void Print(FILE* file, int indent_count, char* fmt, ...) {
|
||||
for(int i = 0; i < indent_count*INDENT_SPACES; i += 1)
|
||||
{
|
||||
fprintf(file, " ");
|
||||
}
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
vfprintf(file, fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
static void PrintNode(MD_Node* node, FILE* file, int indent_count) {
|
||||
Print(file, indent_count, "Node {\n");
|
||||
Print(file, indent_count+1, "Kind: %.*s,\n", MD_S8VArg(MD_StringFromNodeKind(node->kind)));
|
||||
|
||||
int flags_bits = sizeof(node->flags)*8;
|
||||
char binary_flags[sizeof(node->flags)*8+1];
|
||||
binary_flags[flags_bits] = '\0';
|
||||
int flag_index = 0;
|
||||
MD_NodeFlags flags = node->flags;
|
||||
for (int i = 0; i < flags_bits; i++) {
|
||||
binary_flags[i] = (flags&1) ? '1' : '0';
|
||||
flag_index++;
|
||||
flags >>= 1;
|
||||
}
|
||||
|
||||
Print(file, indent_count+1, "Flags: %s,\n", binary_flags);
|
||||
Print(file, indent_count+1, "Flag Names: ", binary_flags);
|
||||
MD_String8List flags_list = MD_StringListFromNodeFlags(arena, node->flags);
|
||||
|
||||
MD_StringJoin join = MD_ZERO_STRUCT;
|
||||
join.mid = MD_S8CString(", ");
|
||||
|
||||
MD_String8 flag_names = MD_S8ListJoin(arena, flags_list, &join);
|
||||
fprintf(file, "%.*s,\n", MD_S8VArg(flag_names));
|
||||
|
||||
if(node->string.size > 0) Print(file, indent_count+1, "String: %.*s,\n", MD_S8VArg(node->string));
|
||||
if(node->raw_string.size > 0) Print(file, indent_count+1, "Whole String: %.*s,\n", MD_S8VArg(node->raw_string));
|
||||
if (node->first_tag->kind != MD_NodeKind_Nil) {
|
||||
for (MD_EachNode(tag, node->first_tag)) {
|
||||
Print(file, indent_count+1, "Tag: @%.*s\n", MD_S8VArg(tag->string));
|
||||
if (tag->first_child->kind != MD_NodeKind_Nil) {
|
||||
Print(file, indent_count+2, "Tag Children{\n");
|
||||
for (MD_EachNode(arg, tag->first_child)) {
|
||||
PrintNode(arg, file, indent_count+3);
|
||||
}
|
||||
Print(file, indent_count+2, "}\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(MD_EachNode(child, node->first_child)) {
|
||||
PrintNode(child, file, indent_count+1);
|
||||
}
|
||||
Print(file, indent_count, "}\n");
|
||||
}
|
||||
|
||||
int main(int argument_count, char **arguments)
|
||||
{
|
||||
arena = MD_ArenaAlloc(1ull << 40);
|
||||
|
||||
// NOTE(pmh): Parse all the files passed in via command line.
|
||||
MD_Node *list = MD_MakeList(arena);
|
||||
for(int i = 1; i < argument_count; i += 1)
|
||||
{
|
||||
MD_Node *root = MD_ParseWholeFile(arena, MD_S8CString(arguments[i])).node;
|
||||
MD_PushNewReference(arena, list, root);
|
||||
}
|
||||
|
||||
for(MD_EachNode(ref, list->first_child))
|
||||
{
|
||||
MD_Node *root = MD_NodeFromReference(ref);
|
||||
MD_String8 code_filename = MD_PathChopLastPeriod(MD_PathSkipLastSlash(root->string));
|
||||
MD_String8 info_filename = MD_S8Fmt(arena, "parsed_%.*s.txt", MD_S8VArg(code_filename));
|
||||
printf("Parse Input -> Output: %.*s -> %.*s\n", MD_S8VArg(code_filename), MD_S8VArg(info_filename));
|
||||
|
||||
FILE* file = fopen((char *)info_filename.str, "wb");
|
||||
for(MD_EachNode(node, root->first_child))
|
||||
{
|
||||
PrintNode(node, file, 0);
|
||||
fprintf(file, "\n");
|
||||
}
|
||||
fclose(file);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
+19
-7
@@ -1,7 +1,19 @@
|
||||
inspecting error information
|
||||
MD_CodeLocFromNode, (MD_Node from MD_Message)
|
||||
nil nodes
|
||||
tips on generating C
|
||||
concat
|
||||
PushStringF
|
||||
match flags (which are relevant)
|
||||
Intro Materials Should Cover:
|
||||
arena
|
||||
string helpers
|
||||
immutable tree model
|
||||
nil
|
||||
|
||||
Examples:
|
||||
[ ] Metadesk parse checker
|
||||
[ ] Metadesk reprinter
|
||||
[ ] Example of helpers: string helpers, linked lists, map type
|
||||
printing errors, cmd line, file iter
|
||||
[ ] Datadesk-like setup
|
||||
[ ] Example type metadata
|
||||
[ ] Example of simple expression parser
|
||||
[ ] Example of C-like expression parser (with value and type expressions)
|
||||
[ ] Example(s) of using overrides
|
||||
[ ] Example memory clearing in long-running program
|
||||
[ ] Example multi-threaded parsing
|
||||
|
||||
|
||||
+1
-1
@@ -31,7 +31,7 @@ command_list =
|
||||
{
|
||||
.name = "all_dev_checks",
|
||||
.out = "*compilation*",
|
||||
.footer_panel = true,
|
||||
.footer_panel = false,
|
||||
.save_dirty_files = true,
|
||||
.cursor_at_end = false,
|
||||
.cmd =
|
||||
|
||||
+1
-2
@@ -665,8 +665,7 @@ typedef enum MD_ParseSetRule
|
||||
{
|
||||
MD_ParseSetRule_EndOnDelimiter,
|
||||
MD_ParseSetRule_Global,
|
||||
}
|
||||
MD_ParseSetRule;
|
||||
} MD_ParseSetRule;
|
||||
|
||||
typedef struct MD_ParseResult MD_ParseResult;
|
||||
struct MD_ParseResult
|
||||
|
||||
Reference in New Issue
Block a user