learn-code-the-hard-way
/
raycaster
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Initial cut of the lel parser mostly working but none of the basic alignment properties work.

Browse Source
Zed A. Shaw 2 months ago
parent e7e0df6b70
commit 846b7aaf16
7 changed files with 492 additions and 354 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      Makefile
  2. 180
      dinkyecs.hpp
  3. 302
      lel.cpp
  4. 42
      lel.hpp
  5. 260
      lel_parser.cpp
  6. 38
      lel_parser.rl
  7. 18
      tests/lel.cpp

4
Makefile
Unescape View File

@ -6,7 +6,7 @@ reset:
%.cpp : %.rl %.cpp : %.rl
ragel -o $@ $< ragel -o $@ $<
build: ansi_parser.cpp lel.cpp build: ansi_parser.cpp lel_parser.cpp
meson compile -j 10 -C builddir meson compile -j 10 -C builddir
release_build: release_build:
@ -22,7 +22,7 @@ tracy_build:
meson compile -j 10 -C builddir meson compile -j 10 -C builddir
test: build test: build
./builddir/runtests ./builddir/runtests "[lel]"
run: build test run: build test
powershell "cp ./builddir/zedcaster.exe ." powershell "cp ./builddir/zedcaster.exe ."

180
dinkyecs.hpp
Unescape View File

@ -1,20 +1,29 @@
#pragma once #pragma once
#include "dbc.hpp"
#include <any>
#include <functional> #include <functional>
#include <queue>
#include <tuple>
#include <typeindex> #include <typeindex>
#include <typeinfo> #include <typeinfo>
#include <unordered_map> #include <unordered_map>
#include <any>
#include <tuple>
#include <queue>
#include "dbc.hpp"
namespace DinkyECS { namespace DinkyECS
{
typedef unsigned long Entity; typedef unsigned long Entity;
using EntityMap = std::unordered_map<Entity, std::any>; using EntityMap = std::unordered_map<Entity, size_t>;
struct Event { template <typename T>
struct ComponentStorage
{
std::vector<T> data;
std::queue<size_t> free_indices;
};
struct Event
{
int event = 0; int event = 0;
Entity entity = 0; Entity entity = 0;
std::any data; std::any data;
@ -22,135 +31,202 @@ namespace DinkyECS {
typedef std::queue<Event> EventQueue; typedef std::queue<Event> EventQueue;
struct World { struct World
{
unsigned long entity_count = 0; unsigned long entity_count = 0;
std::unordered_map<std::type_index, EntityMap> $components; std::unordered_map<std::type_index, EntityMap> $components;
std::unordered_map<std::type_index, std::any> $facts; std::unordered_map<std::type_index, std::any> $facts;
std::unordered_map<std::type_index, EventQueue> $events; std::unordered_map<std::type_index, EventQueue> $events;
std::unordered_map<std::type_index, std::any> $component_storages;
std::vector<Entity> $constants; std::vector<Entity> $constants;
Entity entity() { Entity entity() { return ++entity_count; }
return ++entity_count;
}
void clone_into(DinkyECS::World &to_world) { void clone_into(DinkyECS::World &to_world)
{
to_world.$constants = $constants; to_world.$constants = $constants;
to_world.$facts = $facts; to_world.$facts = $facts;
to_world.entity_count = entity_count; to_world.entity_count = entity_count;
to_world.$component_storages = $component_storages;
for(auto eid : $constants) {
for(const auto &[tid, eid_map] : $components) { for (auto eid : $constants)
auto& their_map = to_world.$components[tid]; {
if(eid_map.contains(eid)) { for (const auto &[tid, eid_map] : $components)
{
auto &their_map = to_world.$components[tid];
if (eid_map.contains(eid))
{
their_map.insert_or_assign(eid, eid_map.at(eid)); their_map.insert_or_assign(eid, eid_map.at(eid));
} }
} }
} }
} }
void make_constant(DinkyECS::Entity entity) { void make_constant(DinkyECS::Entity entity)
{
$constants.push_back(entity); $constants.push_back(entity);
} }
template <typename Comp> template <typename Comp>
EntityMap& entity_map_for() { size_t make_component()
{
auto &storage = component_storage_for<Comp>();
size_t index;
if (!storage.free_indices.empty())
{
index = storage.free_indices.front();
storage.free_indices.pop();
}
else
{
storage.data.emplace_back();
index = storage.data.size() - 1;
}
return index;
}
template <typename Comp>
ComponentStorage<Comp> &component_storage_for()
{
auto type_index = std::type_index(typeid(Comp));
$component_storages.try_emplace(type_index, ComponentStorage<Comp>{});
return std::any_cast<ComponentStorage<Comp> &>(
$component_storages.at(type_index));
}
template <typename Comp>
EntityMap &entity_map_for()
{
return $components[std::type_index(typeid(Comp))]; return $components[std::type_index(typeid(Comp))];
} }
template <typename Comp> template <typename Comp>
EventQueue& queue_map_for() { EventQueue &queue_map_for()
{
return $events[std::type_index(typeid(Comp))]; return $events[std::type_index(typeid(Comp))];
} }
template <typename Comp> template <typename Comp>
void remove(Entity ent) { void remove(Entity ent)
{
EntityMap &map = entity_map_for<Comp>(); EntityMap &map = entity_map_for<Comp>();
if (map.contains(ent))
{
size_t index = map.at(ent);
component_storage_for<Comp>().free_indices.push(index);
}
map.erase(ent); map.erase(ent);
} }
template <typename Comp> template <typename Comp>
void set_the(Comp val) { void set_the(Comp val)
{
$facts.insert_or_assign(std::type_index(typeid(Comp)), val); $facts.insert_or_assign(std::type_index(typeid(Comp)), val);
} }
template <typename Comp> template <typename Comp>
Comp &get_the() { Comp &get_the()
{
auto comp_id = std::type_index(typeid(Comp)); auto comp_id = std::type_index(typeid(Comp));
dbc::check($facts.contains(comp_id), dbc::check($facts.contains(comp_id),
fmt::format("!!!! ATTEMPT to access world fact that hasn't been set yet: {}", typeid(Comp).name())); fmt::format("!!!! ATTEMPT to access world fact that hasn't "
"been set yet: {}",
typeid(Comp).name()));
// use .at to get std::out_of_range if fact not set // use .at to get std::out_of_range if fact not set
std::any &res = $facts.at(comp_id); std::any &res = $facts.at(comp_id);
return std::any_cast<Comp&>(res); return std::any_cast<Comp &>(res);
} }
template <typename Comp> template <typename Comp>
bool has_the() { bool has_the()
{
auto comp_id = std::type_index(typeid(Comp)); auto comp_id = std::type_index(typeid(Comp));
return $facts.contains(comp_id); return $facts.contains(comp_id);
} }
template <typename Comp> template <typename Comp>
void set(Entity ent, Comp val) { void set(Entity ent, Comp val)
{
EntityMap &map = entity_map_for<Comp>(); EntityMap &map = entity_map_for<Comp>();
map.insert_or_assign(ent, val);
if (has<Comp>(ent))
{
get<Comp>(ent) = val;
return;
}
map.insert_or_assign(ent, make_component<Comp>());
get<Comp>(ent) = val;
} }
template <typename Comp> template <typename Comp>
Comp &get(Entity ent) { Comp &get(Entity ent)
{
EntityMap &map = entity_map_for<Comp>(); EntityMap &map = entity_map_for<Comp>();
// use .at for bounds checking auto &storage = component_storage_for<Comp>();
std::any &res = map.at(ent); auto index = map.at(ent);
return std::any_cast<Comp&>(res); return storage.data[index];
} }
template <typename Comp> template <typename Comp>
bool has(Entity ent) { bool has(Entity ent)
{
EntityMap &map = entity_map_for<Comp>(); EntityMap &map = entity_map_for<Comp>();
return map.contains(ent); return map.contains(ent);
} }
template<typename Comp> template <typename Comp>
void query(std::function<void(const Entity&, Comp&)> cb) { void query(std::function<void(const Entity &, Comp &)> cb)
{
EntityMap &map = entity_map_for<Comp>(); EntityMap &map = entity_map_for<Comp>();
for(auto& [entity, any_comp] : map) {
Comp &res = std::any_cast<Comp&>(any_comp); for (auto &[entity, index] : map)
cb(entity, res); {
cb(entity, get<Comp>(entity));
} }
} }
template<typename CompA, typename CompB> template <typename CompA, typename CompB>
void query(std::function<void(const Entity&, CompA&, CompB&)> cb) { void query(std::function<void(const Entity &, CompA &, CompB &)> cb)
{
EntityMap &map_a = entity_map_for<CompA>(); EntityMap &map_a = entity_map_for<CompA>();
EntityMap &map_b = entity_map_for<CompB>(); EntityMap &map_b = entity_map_for<CompB>();
for(auto& [entity, any_a] : map_a) { for (auto &[entity, index_a] : map_a)
if(map_b.contains(entity)) { {
CompA &res_a = std::any_cast<CompA&>(any_a); if (map_b.contains(entity))
CompB &res_b = get<CompB>(entity); {
cb(entity, res_a, res_b); cb(entity, get<CompA>(entity), get<CompB>(entity));
} }
} }
} }
template<typename Comp> template <typename Comp>
void send(Comp event, Entity entity, std::any data) { void send(Comp event, Entity entity, std::any data)
{
EventQueue &queue = queue_map_for<Comp>(); EventQueue &queue = queue_map_for<Comp>();
queue.push({event, entity, data}); queue.push({event, entity, data});
} }
template<typename Comp> template <typename Comp>
Event recv() { Event recv()
{
EventQueue &queue = queue_map_for<Comp>(); EventQueue &queue = queue_map_for<Comp>();
Event evt = queue.front(); Event evt = queue.front();
queue.pop(); queue.pop();
return evt; return evt;
} }
template<typename Comp> template <typename Comp>
bool has_event() { bool has_event()
{
EventQueue &queue = queue_map_for<Comp>(); EventQueue &queue = queue_map_for<Comp>();
return !queue.empty(); return !queue.empty();
} }
}; };
} } // namespace DinkyECS

302
lel.cpp
Unescape View File

@ -1,294 +1,82 @@
#line 1 "lel.rl"
#include "lel.hpp" #include "lel.hpp"
#include <fmt/core.h> #include <fmt/core.h>
#include "lel_parser.cpp"
#line 33 "lel.rl" LELParser::LELParser(int x, int y, int width, int height) :
grid_x(x),
grid_y(y),
grid_w(width),
#line 7 "lel.cpp" grid_h(height),
static const char _LELParser_actions[] = { cur(0, 0)
0, 1, 1, 1, 2, 1, 3, 1, {
4, 1, 5, 1, 6, 1, 9, 1,
10, 1, 11, 2, 0, 7, 2, 0,
8, 2, 4, 1, 2, 4, 5
};
static const char _LELParser_key_offsets[] = {
0, 0, 4, 18, 20, 24, 35, 47,
52, 66, 68, 72, 83, 95, 99, 101,
104, 106, 109
};
static const char _LELParser_trans_keys[] = {
32, 91, 9, 13, 32, 40, 42, 46,
60, 62, 94, 95, 9, 13, 65, 90,
97, 122, 48, 57, 41, 44, 48, 57,
40, 42, 46, 60, 62, 94, 95, 65,
90, 97, 122, 32, 93, 95, 124, 9,
13, 48, 57, 65, 90, 97, 122, 32,
93, 124, 9, 13, 32, 40, 42, 46,
60, 62, 94, 95, 9, 13, 65, 90,
97, 122, 48, 57, 41, 44, 48, 57,
40, 42, 46, 60, 62, 94, 95, 65,
90, 97, 122, 32, 93, 95, 124, 9,
13, 48, 57, 65, 90, 97, 122, 32,
93, 9, 13, 48, 57, 41, 48, 57,
48, 57, 41, 48, 57, 32, 91, 9,
13, 0
};
static const char _LELParser_single_lengths[] = {
0, 2, 8, 0, 2, 7, 4, 3,
8, 0, 2, 7, 4, 2, 0, 1,
0, 1, 2
};
static const char _LELParser_range_lengths[] = {
0, 1, 3, 1, 1, 2, 4, 1,
3, 1, 1, 2, 4, 1, 1, 1,
1, 1, 1
};
static const char _LELParser_index_offsets[] = {
0, 0, 4, 16, 18, 22, 32, 41,
46, 58, 60, 64, 74, 83, 87, 89,
92, 94, 97
};
static const char _LELParser_indicies[] = {
0, 2, 0, 1, 3, 4, 5, 6,
7, 7, 6, 8, 3, 8, 8, 1,
9, 1, 10, 11, 12, 1, 4, 5,
6, 7, 7, 6, 8, 8, 8, 1,
13, 15, 14, 16, 13, 14, 14, 14,
1, 17, 18, 19, 17, 1, 20, 21,
22, 23, 24, 24, 23, 25, 20, 25,
25, 1, 26, 1, 27, 28, 29, 1,
21, 22, 23, 24, 24, 23, 25, 25,
25, 1, 30, 15, 31, 16, 30, 31,
31, 31, 1, 32, 18, 32, 1, 33,
1, 34, 35, 1, 36, 1, 37, 38,
1, 39, 2, 39, 1, 0
};
static const char _LELParser_trans_targs[] = {
1, 0, 2, 2, 3, 5, 5, 5,
6, 4, 5, 16, 4, 7, 6, 18,
8, 7, 18, 8, 8, 9, 11, 11,
11, 12, 10, 11, 14, 10, 13, 12,
13, 15, 11, 15, 17, 5, 17, 18
};
static const char _LELParser_trans_actions[] = {
0, 0, 3, 0, 0, 13, 5, 11,
17, 15, 19, 19, 0, 7, 0, 28,
25, 0, 9, 1, 0, 0, 13, 5,
11, 17, 15, 19, 19, 0, 7, 0,
0, 15, 22, 0, 15, 22, 0, 0
};
static const int LELParser_start = 1;
static const int LELParser_first_final = 18;
static const int LELParser_error = 0;
static const int LELParser_en_main = 1;
#line 36 "lel.rl"
bool LELParser::parse(std::string input) {
int cs = 0;
const char *start = nullptr;
const char *begin = input.data();
const char *p = input.data();
const char *pe = p + input.size();
std::string tk;
#line 103 "lel.cpp"
{
cs = LELParser_start;
}
#line 46 "lel.rl"
#line 106 "lel.cpp"
{
int _klen;
unsigned int _trans;
const char *_acts;
unsigned int _nacts;
const char *_keys;
if ( p == pe )
goto _test_eof;
if ( cs == 0 )
goto _out;
_resume:
_keys = _LELParser_trans_keys + _LELParser_key_offsets[cs];
_trans = _LELParser_index_offsets[cs];
_klen = _LELParser_single_lengths[cs];
if ( _klen > 0 ) {
const char *_lower = _keys;
const char *_mid;
const char *_upper = _keys + _klen - 1;
while (1) {
if ( _upper < _lower )
break;
_mid = _lower + ((_upper-_lower) >> 1);
if ( (*p) < *_mid )
_upper = _mid - 1;
else if ( (*p) > *_mid )
_lower = _mid + 1;
else {
_trans += (unsigned int)(_mid - _keys);
goto _match;
}
}
_keys += _klen;
_trans += _klen;
}
_klen = _LELParser_range_lengths[cs];
if ( _klen > 0 ) {
const char *_lower = _keys;
const char *_mid;
const char *_upper = _keys + (_klen<<1) - 2;
while (1) {
if ( _upper < _lower )
break;
_mid = _lower + (((_upper-_lower) >> 1) & ~1);
if ( (*p) < _mid[0] )
_upper = _mid - 2;
else if ( (*p) > _mid[1] )
_lower = _mid + 2;
else {
_trans += (unsigned int)((_mid - _keys)>>1);
goto _match;
}
}
_trans += _klen;
}
_match:
_trans = _LELParser_indicies[_trans];
cs = _LELParser_trans_targs[_trans];
if ( _LELParser_trans_actions[_trans] == 0 )
goto _again;
_acts = _LELParser_actions + _LELParser_trans_actions[_trans];
_nacts = (unsigned int) *_acts++;
while ( _nacts-- > 0 )
{
switch ( *_acts++ )
{
case 0:
#line 8 "lel.rl"
{tk = input.substr(start - begin, p - start); }
break;
case 1:
#line 10 "lel.rl"
{ col(); }
break;
case 2:
#line 11 "lel.rl"
{ ltab(); }
break;
case 3:
#line 12 "lel.rl"
{ valign((*p)); }
break;
case 4:
#line 13 "lel.rl"
{ id(input.substr(start - begin, p - start)); }
break;
case 5:
#line 14 "lel.rl"
{ row(); }
break;
case 6:
#line 15 "lel.rl"
{ align((*p)); }
break;
case 7:
#line 16 "lel.rl"
{ setwidth(std::stoi(tk)); }
break;
case 8:
#line 17 "lel.rl"
{ setheight(std::stoi(tk)); }
break;
case 9:
#line 18 "lel.rl"
{ expand(); }
break;
case 10:
#line 26 "lel.rl"
{ start = p; }
break;
case 11:
#line 29 "lel.rl"
{start = p;}
break;
#line 215 "lel.cpp"
}
}
_again:
if ( cs == 0 )
goto _out;
if ( ++p != pe )
goto _resume;
_test_eof: {}
_out: {}
}
#line 47 "lel.rl"
bool good = pe - p == 0;
return good;
} }
void LELParser::col() { void LELParser::ltab() {
fmt::println("col"); cur.row = row_count;
fmt::println("ltab: rows {}", row_count);
} }
void LELParser::ltab() { void LELParser::col() {
fmt::println("ltab");
} }
void LELParser::valign(char dir) { void LELParser::valign(char dir) {
cur.top = dir == '^';
fmt::println("valign: {}", dir); fmt::println("valign: {}", dir);
} }
void LELParser::align(char dir) { void LELParser::align(char dir) {
cur.left = dir == '<';
fmt::println("align {}", dir); fmt::println("align {}", dir);
} }
void LELParser::id(std::string name) { void LELParser::id(std::string name) {
fmt::println("id: {}", name); fmt::println("id: {}", name);
cells.insert_or_assign(name, cur);
cur = {cur.col + 1, cur.row};
} }
void LELParser::row() { void LELParser::row() {
fmt::println("row"); row_count++;
max_columns = std::max(max_columns, cur.col);
cur.col = 0;
fmt::println("row end: cols {}", cur.col);
} }
void LELParser::setwidth(int width) { void LELParser::setwidth(int width) {
fmt::println("setwidth: {}", width); fmt::println("setwidth: {}", width);
cur.w = width;
} }
void LELParser::setheight(int height) { void LELParser::setheight(int height) {
fmt::println("setheight: {}", height); fmt::println("setheight: {}", height);
cur.h = height;
} }
void LELParser::expand() { void LELParser::expand() {
fmt::println("expand"); fmt::println("expand");
cur.expand = true;
}
void LELParser::finalize() {
int cell_width = grid_w / max_columns;
int cell_height = grid_h / row_count;
fmt::println("FINALIZE: cell w/h: {},{}", cell_width, cell_height);
for(auto [name, cell] : cells) {
cell.x = cell.col * cell_width;
cell.y = cell.row * cell_height;
if(cell.w == 0) cell.w = cell_width;
if(cell.x == 0) cell.h = cell_height;
fmt::println("name={}; col/row={},{}; x/y={},{} w/h={},{}; left={}, top={}, expand={}",
name, cell.col, cell.row, cell.x, cell.y, cell.w, cell.h, cell.left, cell.top, cell.expand);
}
}
void LELParser::reset() {
row_count = 0;
max_columns = 0;
cur = {0, 0};
} }

42
lel.hpp
Unescape View File

@ -0,0 +1,42 @@
#pragma once
#include <string>
#include <unordered_map>
struct Cell {
int x = 0;
int y = 0;
int w = 0;
int h = 0;
int col = 0;
int row = 0;
bool left = true;
bool top = true;
bool expand = false;
Cell(int col, int row) : col(col), row(row) {}
};
struct LELParser {
int grid_x = 0;
int grid_y = 0;
int grid_w = 0;
int grid_h = 0;
int row_count = 0;
int max_columns = 0;
Cell cur;
std::unordered_map<std::string, Cell> cells;
LELParser(int x, int y, int width, int height);
void col();
void ltab();
void align(char dir);
void valign(char dir);
void id(std::string name);
void row();
void setwidth(int width);
void setheight(int height);
void expand();
void reset();
bool parse(std::string input);
void finalize();
};

260
lel_parser.cpp
Unescape View File

@ -0,0 +1,260 @@
#line 1 "lel_parser.rl"
#include "lel.hpp"
#include <fmt/core.h>
#line 33 "lel_parser.rl"
#line 7 "lel_parser.cpp"
static const char _LELParser_actions[] = {
0, 1, 1, 1, 2, 1, 3, 1,
4, 1, 5, 1, 6, 1, 9, 1,
10, 1, 11, 2, 0, 7, 2, 0,
8, 2, 4, 1, 2, 4, 5
};
static const char _LELParser_key_offsets[] = {
0, 0, 4, 18, 20, 24, 35, 47,
52, 66, 68, 72, 83, 95, 99, 101,
104, 106, 109
};
static const char _LELParser_trans_keys[] = {
32, 91, 9, 13, 32, 40, 42, 46,
60, 62, 94, 95, 9, 13, 65, 90,
97, 122, 48, 57, 41, 44, 48, 57,
40, 42, 46, 60, 62, 94, 95, 65,
90, 97, 122, 32, 93, 95, 124, 9,
13, 48, 57, 65, 90, 97, 122, 32,
93, 124, 9, 13, 32, 40, 42, 46,
60, 62, 94, 95, 9, 13, 65, 90,
97, 122, 48, 57, 41, 44, 48, 57,
40, 42, 46, 60, 62, 94, 95, 65,
90, 97, 122, 32, 93, 95, 124, 9,
13, 48, 57, 65, 90, 97, 122, 32,
93, 9, 13, 48, 57, 41, 48, 57,
48, 57, 41, 48, 57, 32, 91, 9,
13, 0
};
static const char _LELParser_single_lengths[] = {
0, 2, 8, 0, 2, 7, 4, 3,
8, 0, 2, 7, 4, 2, 0, 1,
0, 1, 2
};
static const char _LELParser_range_lengths[] = {
0, 1, 3, 1, 1, 2, 4, 1,
3, 1, 1, 2, 4, 1, 1, 1,
1, 1, 1
};
static const char _LELParser_index_offsets[] = {
0, 0, 4, 16, 18, 22, 32, 41,
46, 58, 60, 64, 74, 83, 87, 89,
92, 94, 97
};
static const char _LELParser_indicies[] = {
0, 2, 0, 1, 3, 4, 5, 6,
7, 7, 6, 8, 3, 8, 8, 1,
9, 1, 10, 11, 12, 1, 4, 5,
6, 7, 7, 6, 8, 8, 8, 1,
13, 15, 14, 16, 13, 14, 14, 14,
1, 17, 18, 19, 17, 1, 20, 21,
22, 23, 24, 24, 23, 25, 20, 25,
25, 1, 26, 1, 27, 28, 29, 1,
21, 22, 23, 24, 24, 23, 25, 25,
25, 1, 30, 15, 31, 16, 30, 31,
31, 31, 1, 32, 18, 32, 1, 33,
1, 34, 35, 1, 36, 1, 37, 38,
1, 39, 2, 39, 1, 0
};
static const char _LELParser_trans_targs[] = {
1, 0, 2, 2, 3, 5, 5, 5,
6, 4, 5, 16, 4, 7, 6, 18,
8, 7, 18, 8, 8, 9, 11, 11,
11, 12, 10, 11, 14, 10, 13, 12,
13, 15, 11, 15, 17, 5, 17, 18
};
static const char _LELParser_trans_actions[] = {
0, 0, 3, 0, 0, 13, 5, 11,
17, 15, 19, 19, 0, 7, 0, 28,
25, 0, 9, 1, 0, 0, 13, 5,
11, 17, 15, 19, 19, 0, 7, 0,
0, 15, 22, 0, 15, 22, 0, 0
};
static const int LELParser_start = 1;
static const int LELParser_first_final = 18;
static const int LELParser_error = 0;
static const int LELParser_en_main = 1;
#line 36 "lel_parser.rl"
bool LELParser::parse(std::string input) {
reset();
int cs = 0;
const char *start = nullptr;
const char *begin = input.data();
const char *p = input.data();
const char *pe = p + input.size();
std::string tk;
#line 104 "lel_parser.cpp"
{
cs = LELParser_start;
}
#line 47 "lel_parser.rl"
#line 107 "lel_parser.cpp"
{
int _klen;
unsigned int _trans;
const char *_acts;
unsigned int _nacts;
const char *_keys;
if ( p == pe )
goto _test_eof;
if ( cs == 0 )
goto _out;
_resume:
_keys = _LELParser_trans_keys + _LELParser_key_offsets[cs];
_trans = _LELParser_index_offsets[cs];
_klen = _LELParser_single_lengths[cs];
if ( _klen > 0 ) {
const char *_lower = _keys;
const char *_mid;
const char *_upper = _keys + _klen - 1;
while (1) {
if ( _upper < _lower )
break;
_mid = _lower + ((_upper-_lower) >> 1);
if ( (*p) < *_mid )
_upper = _mid - 1;
else if ( (*p) > *_mid )
_lower = _mid + 1;
else {
_trans += (unsigned int)(_mid - _keys);
goto _match;
}
}
_keys += _klen;
_trans += _klen;
}
_klen = _LELParser_range_lengths[cs];
if ( _klen > 0 ) {
const char *_lower = _keys;
const char *_mid;
const char *_upper = _keys + (_klen<<1) - 2;
while (1) {
if ( _upper < _lower )
break;
_mid = _lower + (((_upper-_lower) >> 1) & ~1);
if ( (*p) < _mid[0] )
_upper = _mid - 2;
else if ( (*p) > _mid[1] )
_lower = _mid + 2;
else {
_trans += (unsigned int)((_mid - _keys)>>1);
goto _match;
}
}
_trans += _klen;
}
_match:
_trans = _LELParser_indicies[_trans];
cs = _LELParser_trans_targs[_trans];
if ( _LELParser_trans_actions[_trans] == 0 )
goto _again;
_acts = _LELParser_actions + _LELParser_trans_actions[_trans];
_nacts = (unsigned int) *_acts++;
while ( _nacts-- > 0 )
{
switch ( *_acts++ )
{
case 0:
#line 8 "lel_parser.rl"
{tk = input.substr(start - begin, p - start); }
break;
case 1:
#line 10 "lel_parser.rl"
{ col(); }
break;
case 2:
#line 11 "lel_parser.rl"
{ ltab(); }
break;
case 3:
#line 12 "lel_parser.rl"
{ valign((*p)); }
break;
case 4:
#line 13 "lel_parser.rl"
{ id(input.substr(start - begin, p - start)); }
break;
case 5:
#line 14 "lel_parser.rl"
{ row(); }
break;
case 6:
#line 15 "lel_parser.rl"
{ align((*p)); }
break;
case 7:
#line 16 "lel_parser.rl"
{ setwidth(std::stoi(tk)); }
break;
case 8:
#line 17 "lel_parser.rl"
{ setheight(std::stoi(tk)); }
break;
case 9:
#line 18 "lel_parser.rl"
{ expand(); }
break;
case 10:
#line 26 "lel_parser.rl"
{ start = p; }
break;
case 11:
#line 29 "lel_parser.rl"
{start = p;}
break;
#line 216 "lel_parser.cpp"
}
}
_again:
if ( cs == 0 )
goto _out;
if ( ++p != pe )
goto _resume;
_test_eof: {}
_out: {}
}
#line 48 "lel_parser.rl"
bool good = pe - p == 0;
finalize();
return good;
}

38
lel.rl → lel_parser.rl
Unescape View File

@ -35,6 +35,7 @@
%% write data; %% write data;
bool LELParser::parse(std::string input) { bool LELParser::parse(std::string input) {
reset();
int cs = 0; int cs = 0;
const char *start = nullptr; const char *start = nullptr;
const char *begin = input.data(); const char *begin = input.data();
@ -46,42 +47,7 @@ bool LELParser::parse(std::string input) {
%% write exec; %% write exec;
bool good = pe - p == 0; bool good = pe - p == 0;
finalize();
return good; return good;
} }
void LELParser::col() {
fmt::println("col");
}
void LELParser::ltab() {
fmt::println("ltab");
}
void LELParser::valign(char dir) {
fmt::println("valign: {}", dir);
}
void LELParser::align(char dir) {
fmt::println("align {}", dir);
}
void LELParser::id(std::string name) {
fmt::println("id: {}", name);
}
void LELParser::row() {
fmt::println("row");
}
void LELParser::setwidth(int width) {
fmt::println("setwidth: {}", width);
}
void LELParser::setheight(int height) {
fmt::println("setheight: {}", height);
}
void LELParser::expand() {
fmt::println("expand");
}

18
tests/lel.cpp
Unescape View File

@ -6,16 +6,22 @@
#include <codecvt> #include <codecvt>
#include <iostream> #include <iostream>
TEST_CASE("test basic ops", "[lel]") { TEST_CASE("test basic ops", "[lel]") {
LELParser parser; LELParser parser(0, 0, 500, 500);
bool good = parser.parse( bool good = parser.parse(
"[ label_1 | label3 ]" "[ label_1 | *label3 ]"
"[ (300,300)*text1 | (150)people ]" "[ (300,300)text1 | (150)people ]"
"[ <label2 | _ ]" "[ >label2 | _ ]"
"[ message | buttons ]"); "[ message | buttons ]");
REQUIRE(good); REQUIRE(good);
REQUIRE(parser.row_count == 4);
REQUIRE(parser.max_columns == 2);
REQUIRE(parser.cells.size() == 8);
REQUIRE(parser.cells.at("label2").left == false);
REQUIRE(parser.cells.at("label3").expand == true);
REQUIRE(parser.cells.at("people").expand == false);
REQUIRE(parser.cells.at("message").expand == false);
} }

Write Preview
Loading…
Cancel
Save