ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tmp

Browse source
This commit is contained in:
Ilusha 2024-03-07 12:31:26 +03:00
parent 93b02416de
commit 1f1dc001a1
8 changed files with 124 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Containers/public/List.hpp
View file

@ -18,7 +18,7 @@ namespace tp {
Type data;
Node* next = nullptr;
Node* prev = nullptr;
Node() = default;
Node() { data = Type(); }
explicit Node(TypeArg p_data) :
data(p_data) {}
Type& operator->() { return data; }

1
Externals/lalr vendored Submodule

@ -0,0 +1 @@
Subproject commit ebf41832eb51205afd7aaf3e097d0a6197fefc26

116
Language/public/Automata.hpp
View file

@ -47,6 +47,7 @@ namespace tp {
class State {
friend FiniteStateAutomation;
public:
State() = default;
public:
@ -61,7 +62,7 @@ namespace tp {
private:
List<State> mStates;
const State* mStartState = nullptr;
State* mStartState = nullptr;
public:
FiniteStateAutomation() = default;
@ -69,18 +70,18 @@ namespace tp {
State* addState(const tStateType& state, bool accepting) {
auto node = mStates.newNode();
node->data.mIsAccepting = accepting;
node->data.mState = state;
node->data.mStateVal = state;
mStates.pushBack(node);
return &node->data;
}
void addTransition(State* from, State* to, const tAlphabetType& symbol) {
from->edges.pushBack(Transition(Transition::SYMBOL, to, symbol));
from->mTransitions.append(Transition(Transition::SYMBOL, to, symbol));
}
void addEpsilonTransition(State* from, State* to) { from->edges.pushBack(Transition(Transition::SYMBOL, to)); }
void addEpsilonTransition(State* from, State* to) { from->mTransitions.append(Transition(Transition::SYMBOL, to)); }
void addAnyTransition(State* from, State* to) { from->edges.pushBack(Transition(Transition::ANY, to)); }
void addAnyTransition(State* from, State* to) { from->mTransitions.append(Transition(Transition::ANY, to)); }
void setStartVertex(State* start) { mStartState = start; }
@ -96,7 +97,7 @@ namespace tp {
// vertices that are reachable from initial set with no input consumption (E-transitions)
// does not include initial set
void findClosureSet(const Buffer<State*>& from, Buffer<State*>& closureSet) const {
Map<State*, bool> lookup;
Map<alni, bool> lookup;
List<State*> workingSet;
for (auto item : from) {
@ -106,10 +107,11 @@ namespace tp {
while (workingSet.length()) {
auto first = workingSet.first()->data;
closureSet.append(first);
lookup.put((alni) first, {});
for (auto edge : first->mTransitions) {
if (!edge.data().isEpsilon()) continue;
if (lookup.presents(edge.data().mState)) continue;
if (lookup.presents((alni) edge.data().mState)) continue;
workingSet.pushBack(edge.data().mState);
}
@ -119,88 +121,118 @@ namespace tp {
// vertices that are reachable from initial set with symbol transition
void findMoveSet(const Buffer<State*>& from, Buffer<State*>& moveSet, tAlphabetType symbol) const {
Map<State*, bool> lookup;
Map<alni, bool> lookup;
for (auto vertex : from) {
for (auto edge : vertex.mTransitions) {
if (edge.data().isepsilon()) continue;
for (auto edge : vertex->mTransitions) {
if (edge.data().isEpsilon()) continue;
if (!edge.data().isTransition(symbol)) continue;
if (lookup.presents(edge.data().mState)) continue;
if (lookup.presents((alni) edge.data().mState)) continue;
moveSet.append(edge.data().mState);
lookup.put(edge.data().mState, {});
lookup.put((alni) edge.data().mState, {});
}
}
}
template <typename tAlphabetIterator>
bool makeDeterministic(const tAlphabetIterator& allSymbols) {
if (!isValid()) {
return false;
}
if (!isValid()) return false;
struct Group {
Buffer<State*> states;
AvlTree<Group*, tAlphabetType> transitions;
typedef Buffer<State*> Group;
struct GroupKey {
const Group* group;
static ualni hash(GroupKey key) { return 0; }
bool operator==(const GroupKey& key) const { return false; }
};
struct GroupInfo {
Group* group = nullptr;
AvlTree<AvlNumericKey<alni>, tAlphabetType> transitions;
State* newState = nullptr;
bool accepting = false;
tStateType stateVal = tStateType();
};
struct GroupKey {
const Group* group;
};
Buffer<Group> groups = { {} };
Map<GroupKey, GroupInfo, DefaultAllocator, GroupKey::hash> groupInfos;
Buffer<Group> newStates = { {} };
findClosureSet({ getStartState() }, groups.first());
groupInfos.put({ &groups.first() }, { &groups.first() });
// 1) find new states
Map<GroupKey, bool> lookup;
List<Group*> workingSet;
workingSet.pushBack(&groups.first());
findClosureSet({ getStartState() }, newStates.first().states);
workingSet.pushBack(&newStates.first());
while (workingSet.length()) {
auto group = workingSet.first();
Group* group = workingSet.first()->data;
GroupInfo* info = &groupInfos.get({ group });
for (auto symbol : allSymbols) {
// calculate new possible state
Group potentialGroupTmp;
Group potentialGroup;
findMoveSet(group.states, potentialGroup.states, symbol);
if (!potentialGroup.states.size()) continue;
findMoveSet(*group, potentialGroupTmp, symbol);
findClosureSet(potentialGroupTmp, potentialGroup);
if (!potentialGroup.size()) continue;
// find existing or create group
Group* targetGroup = nullptr;
auto iter = lookup.presents({ &potentialGroup });
auto iter = groupInfos.presents({ &potentialGroup });
if (iter) {
targetGroup = lookup.getSlotVal(iter);
targetGroup = groupInfos.getSlotVal(iter).group;
} else {
targetGroup = newStates.append({});
lookup.put({ targetGroup }, {});
targetGroup = &groups.append(potentialGroup);
groupInfos.put({ targetGroup }, { targetGroup });
workingSet.pushBack(targetGroup);
}
// add transition
group.transitions.insert(targetGroup, symbol);
// assert transition is added
info->transitions.insert((alni) targetGroup, symbol);
}
workingSet.popFront();
}
// 2) find new states termination values
// ...
for (auto group : groupInfos) {
GroupInfo* info = &group->val;
bool accepting = false;
for (auto item : *info->group) {
if (item->mIsAccepting) {
if (accepting) return false;
accepting = true;
info->accepting = true;
info->stateVal = item->mStateVal;
}
}
if (!accepting) {
info->accepting = false;
info->stateVal = info->group->first()->mStateVal;
}
}
// 3) transfer
mStates.removeAll();
for (auto group : newStates) {
group.newState = addState();
// create states
for (auto group : groupInfos) {
group->val.newState = addState(group->val.stateVal, group->val.accepting);
}
for (auto group : newStates) {
for (auto transition : group.transitions) {
addTransition(/* ... */);
}
// create transitions
for (auto group : groupInfos) {
auto functor = [&](AvlNumericKey<alni> targetGroupKey, tAlphabetType symbol) {
GroupInfo* targetGroup = &groupInfos.get({ (Group*) targetGroupKey.val });
addTransition(group->val.newState, targetGroup->newState, symbol);
};
group->val.transitions.forEach(functor);
}
return true;
}
};
}

4
Language/public/ContextFreeCompiler.hpp
View file

@ -21,8 +21,8 @@ namespace tp {
ualni mAdvanceIdx;
};
typedef NFA<Alphabet, Item> NFA;
typedef typename NFA::Vertex State;
typedef FiniteStateAutomation<Alphabet, Item> NFA;
typedef typename NFA::State State;
public:
void compile(const Grammar& in, NFA& out) { nfa = &out; }

6
Language/public/Parser.hpp
View file

@ -11,12 +11,12 @@ namespace tp {
class Parser {
typedef TransitionMatrix<tAlphabetType, TokenType, TokenType::InTransition, TokenType::Failed> RegularTable;
typedef DFA<tAlphabetType, TokenType> RegularGraph;
typedef FiniteStateAutomation<tAlphabetType, TokenType> RegularGraph;
typedef RegularCompiler<tAlphabetType, TokenType, TokenType::InTransition, TokenType::Failed> RegularCompiler;
typedef NFA<tAlphabetType, TokenType> RegularNonDetGraph;
typedef FiniteStateAutomation<tAlphabetType, TokenType> RegularNonDetGraph;
// ContextFreeCompiler::Alphabet PushDownTable;
typedef DFA<ContextFreeCompiler::Alphabet, ContextFreeCompiler::Item> ContextFreeDFA;
typedef FiniteStateAutomation<ContextFreeCompiler::Alphabet, ContextFreeCompiler::Item> ContextFreeDFA;
typedef ContextFreeCompiler::NFA ContextFreeNFA;
public:

9
Language/public/RegularAutomata.hpp
View file

@ -27,8 +27,11 @@ namespace tp {
auto getTransitions() const { return &mTransitions; }
auto getStart() const { return mStart; }
void construct(const DFA<tAlphabetType, tStateType>& dfa) {
mSymbolRange = { dfa.getRange().first(), dfa.getRange().last() };
void construct(const FiniteStateAutomation<tAlphabetType, tStateType>& dfa) {
// mSymbolRange = { dfa.getRange().first(), dfa.getRange().last() };
ASSERT(0);
/*
auto range_len = ualni(mSymbolRange.mEnd - mSymbolRange.mBegin);
auto sizeX = range_len ? range_len : 1;
auto sizeY = (ualni) (dfa.nVertices() + 1);
@ -67,6 +70,8 @@ namespace tp {
}
vertexIdx++;
}
*/
}
bool isTrapped() { return mStates[mIter] == tFailedStateVal; }

31
Language/public/RegularCompiler.hpp
View file

@ -9,8 +9,8 @@ namespace tp {
template <typename tAlphabetType, typename tStateType, tStateType tNoStateVal, tStateType tFailedStateVal>
class RegularCompiler {
typedef NFA<tAlphabetType, tStateType> Graph;
typedef typename Graph::Vertex Vertex;
typedef FiniteStateAutomation<tAlphabetType, tStateType> Graph;
typedef typename Graph::State Vertex;
typedef RegularGrammar<tAlphabetType, tStateType> Grammar;
struct Node {
@ -69,8 +69,9 @@ namespace tp {
auto node = compileNode(astNode, nullptr, nullptr);
mGraph->setVertexState(node.right, state, true);
mGraph->setStartVertex(node.left);
// mGraph->setVertexState(node.right, state, true);
// mGraph->setStartVertex(node.left);
ASSERT(0);
return node;
}
@ -173,21 +174,29 @@ namespace tp {
}
void transitionAny(Vertex* from, Vertex* to, bool consumes = false) {
mGraph->addTransition(from, to, {}, consumes, true, false);
// mGraph->addTransition(from, to, {}, consumes, true, false);
ASSERT(0);
}
void transitionVal(Vertex* from, Vertex* to, tAlphabetType val) {
mGraph->addTransition(from, to, { val, val }, true, false, false);
// mGraph->addTransition(from, to, { val, val }, true, false, false);
ASSERT(0);
}
void transitionRange(Vertex* from, Vertex* to, Range<tAlphabetType> range, bool exclude) {
mGraph->addTransition(from, to, range, true, false, exclude);
// mGraph->addTransition(from, to, range, true, false, exclude);
ASSERT(0);
}
Vertex* addVertex() { return mGraph->addVertex(tNoStateVal, false); }
Vertex* addVertex() {
// return mGraph->addVertex(tNoStateVal, false);
ASSERT(0);
return nullptr;
}
private:
Range<tAlphabetType> getAlphabetRange() const {
/*
tAlphabetType start = 0, end = 0;
Range<tAlphabetType> all_range(
std::numeric_limits<tAlphabetType>::min(), std::numeric_limits<tAlphabetType>::max()
@ -204,14 +213,16 @@ namespace tp {
first = false;
}
}
return Range<tAlphabetType>(start, end + 1);
*/
ASSERT(0);
return {};
}
void setAlphabet() {
auto range = getAlphabetRange();
for (auto iter : range) {
mGraph->mAllSymbols.append(iter);
// mGraph->mAllSymbols.append(iter);
}
}
};

15
Language/tests/Tests.cpp
View file

@ -3,6 +3,20 @@
using namespace tp;
void testAutomation() {
FiniteStateAutomation<char, int> automata;
auto start = automata.addState(0, false);
auto end = automata.addState(1, true);
automata.addTransition(start, end, 'a');
automata.setStartVertex(start);
automata.makeDeterministic(Range<char>(10, 30));
}
void test() {
auto parser = SimpleParser<int1>();
auto ast = AST();
@ -20,6 +34,7 @@ int main() {
return 1;
}
testAutomation();
test();
testModule.deinitialize();