├── Automata
    ├── Automata.cpp
    ├── Automata.h
    ├── FA.cpp
    └── FA.h
├── CMakeLists.txt
├── ERE.cpp
├── ERE.filters
├── ERE.vcxproj
├── ERE.vcxproj.filters
├── ERE.vcxproj.user
├── LICENSE
├── Parser
    ├── BREParser.cpp
    └── BREParser.h
├── README.md
├── doc
    ├── 1.png
    ├── DFA.dot.png
    ├── NFA.dot.png
    └── min_DFA.dot.png
├── third_part
    └── ATMPL
    │   ├── LICENSE
    │   ├── README.md
    │   ├── any
    │       ├── any.hpp
    │       ├── readme.md
    │       └── test.cpp
    │   ├── functinal_helper
    │       ├── bind.hpp
    │       ├── func_traits.hpp
    │       ├── readme.md
    │       └── test.cpp
    │   └── optional
    │       ├── optional.hpp
    │       ├── optional_test.cpp
    │       └── readme.md
└── util
    ├── Set.cpp
    └── Set.h


/Automata/Automata.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yufengzjj/ERE/5c62b344472754dc67b75038de7193e653e1e37d/Automata/Automata.cpp


--------------------------------------------------------------------------------
/Automata/Automata.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <set>
  4 | #include <forward_list>
  5 | #include <utility>
  6 | #include <memory>
  7 | #include <stack>
  8 | #include <iostream>
  9 | #include <array>
 10 | #include <limits>
 11 | #include <fstream>
 12 | #include <iterator>
 13 | #include <string>
 14 | #include <exception>
 15 | #include "../third_part/ATMPL/optional/optional.hpp"
 16 | #include "../util/Set.h"
 17 | template<typename _State = int, typename _Driver = char, typename _Sigma = std::string>
 18 | class Automata
 19 | {
 20 | public:
 21 | 	enum { epsilon = 1 };
 22 | 	enum { invalid_state = -1 };
 23 | 	//the set must impl unique insert().
 24 | 	using state_set = Set<_State>;
 25 | 	Automata(_Sigma sigma);
 26 | 	explicit Automata(const _Driver& d, _Sigma sigma);
 27 | 	Automata(const Automata& ato_);
 28 | 	Automata& operator=(const Automata& ato_);
 29 | 	Automata& operator=(Automata&& ato_);
 30 | 	Automata(Automata&& ato_);
 31 | 	Automata clone() const;
 32 | 	~Automata() {}
 33 | 
 34 | 	_State gen_state();
 35 | 	void add_edge(_State src, _State dest, _Driver d);
 36 | 	void remove_edge(_State src, _State dest, _Driver d);
 37 | 	void set_start(_State s);
 38 | 	void set_accept(_State s);
 39 | 	void set_accept(state_set s);
 40 | 	void cancle_accept(_State s);
 41 | 	void cancle_accept(state_set s);
 42 | 	state_set get_accepts();
 43 | 	_State get_start();
 44 | 	state_set get_states();
 45 | 	_State direct_to(_State src, _Driver d);
 46 | 	state_set direct_to(state_set src, _Driver d);
 47 | 	state_set e_closure(_State s);
 48 | 	state_set e_closure(state_set s);
 49 | 
 50 | 	//operations
 51 | 	Automata operator|(Automata& ato_);
 52 | 	Automata operator+(Automata& ato_);
 53 | 	Automata closure();
 54 | 	void determinate();
 55 | 	void minimize();
 56 | 	bool consume(_Driver d);
 57 | 	_State cur_state();
 58 | 
 59 | 	//port to third
 60 | 	void print(std::string name);
 61 | 
 62 | 	class AutomataException :public std::exception
 63 | 	{
 64 | 	public:
 65 | 		AutomataException(std::string msg) :msg_(msg) {}
 66 | 		virtual const char* what() const noexcept
 67 | 		{
 68 | 			return msg_.c_str();
 69 | 		}
 70 | 	private:
 71 | 		std::string msg_;
 72 | 	};
 73 | private:
 74 | 	struct State :public std::enable_shared_from_this<State>
 75 | 	{
 76 | 		using direc_list = std::forward_list<
 77 | 			std::pair<_Driver, State>>;
 78 | 		using direc_ptr = std::shared_ptr<direc_list>;
 79 | 		State(_State s, direc_ptr dptr)
 80 | 		{
 81 | 			state_ = s;
 82 | 			directed_ = dptr;
 83 | 		}
 84 | 		friend bool operator==(const State& lhs, const State& rhs)
 85 | 		{
 86 | 			return lhs.state_ == rhs.state_;
 87 | 		}
 88 | 		friend bool operator<(const State& lhs, const State& rhs)
 89 | 		{
 90 | 			return lhs.state_ < rhs.state_;
 91 | 		}
 92 | 
 93 | 		_State state_;
 94 | 		direc_ptr directed_;
 95 | 	};
 96 | 	typename Automata<_State, _Driver, _Sigma>::State add_state(_State s);
 97 | 	ATMPL::optional<typename Automata<_State, _Driver, _Sigma>::State> find_state(_State s);
 98 | 	typename Automata<_State, _Driver, _Sigma>::State::direc_ptr alloc_drc_ptr();
 99 | private:
100 | 	state_set accept_;
101 | 	_State start_;
102 | 	_State cur_state_;
103 | 	static _State seed_;
104 | 	_Sigma sigma_;
105 | 
106 | 	std::forward_list<State> graph_;
107 | };
108 | 
109 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma /*= std::string*/>
110 | _State Automata<_State, _Driver, _Sigma>::cur_state()
111 | {
112 | 	return cur_state_;
113 | }
114 | 
115 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma /*= std::string*/>
116 | bool Automata<_State, _Driver, _Sigma>::consume(_Driver d)
117 | {
118 | 	auto st = direct_to(cur_state_, d);
119 | 	if (st != invalid_state)
120 | 	{
121 | 		cur_state_ = st;
122 | 		return true;
123 | 	}
124 | 	return false;
125 | 
126 | }
127 | 
128 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma >
129 | void Automata<_State, _Driver, _Sigma>::minimize()
130 | {
131 | 	state_set origin;
132 | 	for (auto s : graph_)
133 | 	{
134 | 		origin.insert(s.state_);
135 | 	}
136 | 	std::forward_list<state_set> equivalence;
137 | 	using index = typename std::forward_list<state_set>::iterator::difference_type;
138 | 	auto eq_drt = [&](_State s, _Driver d)->index
139 | 	{
140 | 		_State s_ = direct_to(s, d);
141 | 		if (s_ == invalid_state)
142 | 		{
143 | 			s_ = s;
144 | 		}
145 | 		for (auto i = equivalence.begin(); i != equivalence.end(); ++i)
146 | 		{
147 | 			if (i->find(s_) != i->end())
148 | 			{
149 | 				return std::distance(equivalence.begin(), i);
150 | 			}
151 | 		}
152 | 		throw AutomataException("unexpected state" + std::to_string(s_));
153 | 	};
154 | 	if (!accept_.empty())
155 | 	{
156 | 		equivalence.push_front(accept_);
157 | 
158 | 	}
159 | 	if (!(origin - accept_).empty())
160 | 	{
161 | 		equivalence.push_front(origin - accept_);
162 | 	}
163 | 	else
164 | 	{
165 | 		//in this consequence it should not use minimizing algorithm
166 | 		return;
167 | 	}
168 | 	
169 | 	bool done = false;
170 | 	while (!done)//calculate equivalence state set
171 | 	{
172 | 		done = true;
173 | 		for (auto states = equivalence.begin(); states != equivalence.end(); ++states)
174 | 		{
175 | 			if (states->size() <= 1)
176 | 			{
177 | 				continue;
178 | 			}
179 | 			state_set apart_states;
180 | 			for (auto d : sigma_)
181 | 			{
182 | 				index first = eq_drt(*states->begin(), d);
183 | 				for (auto c = ++states->begin(); c != states->end(); ++c)
184 | 				{
185 | 					index cur = eq_drt(*c, d);
186 | 					if (cur != first)
187 | 					{
188 | 						apart_states.insert(*c);
189 | 					}
190 | 				}
191 | 				if (!apart_states.empty())
192 | 				{
193 | 					break;
194 | 				}
195 | 			}
196 | 			if (!apart_states.empty())
197 | 			{
198 | 				done = false;
199 | 				equivalence.push_front(apart_states);
200 | 				*states = *states - apart_states;
201 | 				break;
202 | 			}
203 | 		}
204 | 	}
205 | 
206 | 	Automata<_State, _Driver, _Sigma> ato(sigma_);
207 | 	std::forward_list<_State> equivalence_state;
208 | 	auto eq_drive = [&](_State s, _Driver d)->ATMPL::optional<index>
209 | 	{
210 | 		_State s_ = direct_to(s, d);
211 | 		if (s_ == invalid_state)
212 | 		{
213 | 			return ATMPL::optional<index>();
214 | 		}
215 | 		for (auto i = equivalence.begin(); i != equivalence.end(); ++i)
216 | 		{
217 | 			if (i->find(s_) != i->end())
218 | 			{
219 | 				return std::distance(equivalence.begin(), i);
220 | 			}
221 | 		}
222 | 		throw AutomataException("unexpected state" + std::to_string(s_));
223 | 	};
224 | 	for (auto i = equivalence.begin(); i != equivalence.end(); ++i)
225 | 	{
226 | 		equivalence_state.push_front(gen_state());
227 | 	}
228 | 	//generate new automata from equivalence state set.
229 | 	for (auto eq = equivalence.begin(); eq != equivalence.end(); ++eq)
230 | 	{
231 | 		for (auto d : sigma_)
232 | 		{
233 | 			auto index_ = eq_drive(*eq->begin(), d);
234 | 			if (index_)
235 | 			{
236 | 				auto eq_state_src = equivalence_state.begin();
237 | 				auto eq_state_dst = equivalence_state.begin();
238 | 				std::advance(eq_state_src, std::distance(equivalence.begin(), eq));
239 | 				std::advance(eq_state_dst, *index_);
240 | 				ato.add_edge(*eq_state_src, *eq_state_dst, d);
241 | 			}
242 | 		}
243 | 		auto eq_state_i = equivalence_state.begin();
244 | 		std::advance(eq_state_i, std::distance(equivalence.begin(), eq));
245 | 		if (!(*eq & accept_).empty())
246 | 		{
247 | 			ato.set_accept(*eq_state_i);
248 | 		}
249 | 		if (eq->find(start_) != eq->end())
250 | 		{
251 | 			ato.set_start(*eq_state_i);
252 | 		}
253 | 		
254 | 
255 | 	}
256 | 	*this = ato;
257 | }
258 | 
259 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
260 | void Automata<_State, _Driver, _Sigma>::determinate()
261 | {
262 | 	std::forward_list<state_set> walker;
263 | 	std::forward_list<std::pair<_State, state_set>> state_set2state;
264 | 	auto state_find = [&](state_set s)->ATMPL::optional<_State> {
265 | 		for (auto m : state_set2state)
266 | 		{
267 | 			if (m.second == s)
268 | 			{
269 | 				return m.first;
270 | 			}
271 | 		}
272 | 		return ATMPL::optional<_State>();
273 | 	};
274 | 	std::forward_list<state_set> traverse;
275 | 	Automata<_State, _Driver, _Sigma> ato(sigma_);
276 | 	//init
277 | 	state_set2state.push_front(std::make_pair(gen_state(), e_closure({ start_ })));
278 | 	walker.push_front(state_set2state.front().second);
279 | 	ato.set_start(state_set2state.front().first);
280 | 	traverse.push_front(state_set2state.front().second);
281 | 	//stop until no new sets.
282 | 	while (!walker.empty())
283 | 	{
284 | 		auto s = walker.front();
285 | 		walker.pop_front();
286 | 
287 | 		for (auto d : sigma_)
288 | 		{
289 | 			auto st = direct_to(s, d);
290 | 			if (!st.empty())
291 | 			{
292 | 				st = e_closure(st);
293 | 				if (std::find(traverse.begin(), traverse.end(), st) == traverse.end())
294 | 				{
295 | 					traverse.push_front(st);
296 | 					walker.push_front(st);
297 | 				}
298 | 
299 | 				auto start = state_find(s);
300 | 				if (start)
301 | 				{
302 | 					auto end = state_find(st);
303 | 					if (end)
304 | 					{
305 | 						ato.add_edge(*start, *end, d);
306 | 					}
307 | 					else
308 | 					{
309 | 						state_set2state.push_front(std::make_pair(gen_state(), st));
310 | 						ato.add_edge(*start, state_set2state.front().first, d);
311 | 					}
312 | 
313 | 				}
314 | 			}
315 | 
316 | 		}
317 | 
318 | 	}
319 | 
320 | 	//mark accept states
321 | 	state_set accept;
322 | 	for (auto a : state_set2state)
323 | 	{
324 | 		for (auto acp : accept_)
325 | 		{
326 | 			if (a.second.find(acp) != a.second.end())
327 | 			{
328 | 				accept.insert(a.first);
329 | 			}
330 | 		}
331 | 
332 | 	}
333 | 	ato.set_accept(accept);
334 | 	*this = ato;
335 | }
336 | 
337 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
338 | Automata<_State, _Driver, _Sigma> Automata<_State, _Driver, _Sigma>::closure()
339 | {
340 | 	auto ato = clone();
341 | 	auto start = gen_state();
342 | 	auto accept = gen_state();
343 | 	for (auto acp : ato.accept_)
344 | 	{
345 | 		ato.add_edge(acp, ato.start_, epsilon);
346 | 		ato.add_edge(acp, accept, epsilon);
347 | 	}
348 | 	ato.add_edge(start, ato.start_, epsilon);
349 | 	ato.add_edge(start, accept, epsilon);
350 | 	ato.set_start(start);
351 | 	ato.accept_.clear();
352 | 	ato.set_accept(accept);
353 | 	return ato;
354 | }
355 | 
356 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
357 | Automata<_State, _Driver, _Sigma>
358 | Automata<_State, _Driver, _Sigma>::operator+(Automata& ato_)
359 | {
360 | 	auto ato = clone();
361 | 	ato.graph_.sort();
362 | 	ato_.graph_.sort();
363 | 	ato.graph_.merge(ato_.graph_);
364 | 	ato.graph_.unique();
365 | 	for (auto accept : ato.accept_)
366 | 	{
367 | 		ato.add_edge(accept, ato_.start_, epsilon);
368 | 	}
369 | 	ato.accept_.clear();
370 | 	ato.set_accept(ato_.accept_);
371 | 	return ato;
372 | }
373 | 
374 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
375 | Automata<_State, _Driver, _Sigma>::Automata(_Sigma sigma)
376 | 	:start_(invalid_state),
377 | 	sigma_(sigma)
378 | {
379 | 	//std::cout << "Default constructor" << std::endl;
380 | }
381 | 
382 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
383 | Automata<_State, _Driver, _Sigma>& Automata<_State, _Driver, _Sigma>::operator=(Automata&& ato_)
384 | {
385 | 	//std::cout << "Move assignment operator" << std::endl;
386 | 	set_start(ato_.get_start());
387 | 	accept_.clear();
388 | 	set_accept(ato_.get_accepts());
389 | 	graph_ = ato_.graph_;
390 | 	sigma_ = ato_.sigma_;
391 | 	return *this;
392 | }
393 | 
394 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
395 | void Automata<_State, _Driver, _Sigma>::print(std::string name)
396 | {
397 | 	std::ofstream out(name);
398 | 	out << "digraph{" << std::endl;
399 | 	out << R"(rankdir="LR";)" << std::endl;
400 | 	out << R"(fontname = "Microsoft YaHei";)" << std::endl;
401 | 	out << R"(node [shape = circle, fontname = "Microsoft YaHei"];)" << std::endl;
402 | 	out << R"(edge [fontname = "Microsoft YaHei"];)" << std::endl;
403 | 	out << R"(-1[style=invis];)" << std::endl;
404 | 	for (auto acp : accept_)
405 | 	{
406 | 		out << acp << R"( [ shape = doublecircle ];)" << std::endl;
407 | 	}
408 | 	out << "-1 -> " << get_start() << ";" << std::endl;
409 | 	for (auto state : graph_)
410 | 	{
411 | 		for (auto drct : *state.directed_)
412 | 		{
413 | 			if (drct.first == epsilon)
414 | 			{
415 | 				out << state.state_ << " -> " << drct.second.state_ << R"([ label = )" << "<&epsilon;>" << R"( ];)" << std::endl;
416 | 			}
417 | 			else
418 | 			{
419 | 				out << state.state_ << " -> " << drct.second.state_ << R"([ label = ")" << drct.first << R"(" ];)" << std::endl;
420 | 			}
421 | 
422 | 		}
423 | 	}
424 | 	out << "}";
425 | 	out.flush();
426 | 	out.close();
427 | }
428 | 
429 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
430 | typename Automata<_State, _Driver, _Sigma>::State::direc_ptr
431 | Automata<_State, _Driver, _Sigma>::alloc_drc_ptr()
432 | {
433 | 	return typename Automata<_State, _Driver, _Sigma>::State::direc_ptr
434 | 	(new typename Automata<_State, _Driver, _Sigma>::State::direc_list);
435 | }
436 | 
437 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
438 | typename Automata<_State, _Driver, _Sigma>::State
439 | Automata<_State, _Driver, _Sigma>::add_state(_State s)
440 | {
441 | 	auto state = find_state(s);
442 | 	if (!state)
443 | 	{
444 | 		graph_.push_front(State(s, alloc_drc_ptr()));
445 | 		return graph_.front();
446 | 	}
447 | 	return *state;
448 | }
449 | 
450 | template<typename _State, typename _Driver, typename _Sigma>
451 | inline typename Automata<_State, _Driver, _Sigma>::state_set
452 | Automata<_State, _Driver, _Sigma>::get_accepts()
453 | {
454 | 	return accept_;
455 | }
456 | 
457 | template<typename _State, typename _Driver, typename _Sigma>
458 | inline _State Automata<_State, _Driver, _Sigma>::get_start()
459 | {
460 | 	return start_;
461 | }
462 | 
463 | template<typename _State, typename _Driver, typename _Sigma>
464 | inline typename Automata<_State, _Driver, _Sigma>::state_set
465 | Automata<_State, _Driver, _Sigma>::get_states()
466 | {
467 | 	state_set st;
468 | 	for (auto s : graph_)
469 | 	{
470 | 		st.insert(s.state_);
471 | 	}
472 | 	return st;
473 | }
474 | 
475 | template<typename _State, typename _Driver, typename _Sigma>
476 | inline _State Automata<_State, _Driver, _Sigma>::direct_to(_State src, _Driver d)
477 | {
478 | 	auto s = find_state(src);
479 | 	if (s)
480 | 	{
481 | 		for (auto edge : (*(*s).directed_))
482 | 		{
483 | 			if (edge.first == d)
484 | 			{
485 | 				return edge.second.state_;
486 | 			}
487 | 		}
488 | 
489 | 	}
490 | 	return _State(invalid_state);
491 | }
492 | 
493 | template<typename _State, typename _Driver, typename _Sigma>
494 | inline typename Automata<_State, _Driver, _Sigma>::state_set
495 | Automata<_State, _Driver, _Sigma>::direct_to(state_set src, _Driver d)
496 | {
497 | 	state_set st;
498 | 	for (auto s : src)
499 | 	{
500 | 		st.insert(direct_to(s, d));
501 | 	}
502 | 	st.erase(invalid_state);
503 | 	return st;
504 | }
505 | 
506 | template<typename _State, typename _Driver, typename _Sigma>
507 | inline typename Automata<_State, _Driver, _Sigma>::state_set
508 | Automata<_State, _Driver, _Sigma>::e_closure(_State s)
509 | {
510 | 	state_set st;
511 | 	std::stack<_State> walker;
512 | 	walker.push(s);
513 | 	while (!walker.empty())
514 | 	{
515 | 		auto state = walker.top();
516 | 		walker.pop();
517 | 		auto node = find_state(state);
518 | 		if (node)
519 | 		{
520 | 			for (auto s_ : *((*node).directed_))
521 | 			{
522 | 				if (s_.first == epsilon && st.find(s_.second.state_) == st.end())
523 | 				{
524 | 					walker.push(s_.second.state_);
525 | 				}
526 | 			}
527 | 		}
528 | 		st.insert(state);
529 | 	}
530 | 	return st;
531 | }
532 | 
533 | template<typename _State, typename _Driver, typename _Sigma>
534 | inline typename Automata<_State, _Driver, _Sigma>::state_set
535 | Automata<_State, _Driver, _Sigma>::e_closure(state_set s)
536 | {
537 | 	state_set st;
538 | 	for (auto s_ : s)
539 | 	{
540 | 		auto st_ = e_closure(s_);
541 | 		st.insert(st_.begin(), st_.end());
542 | 	}
543 | 	return st;
544 | }
545 | 
546 | template<typename _State, typename _Driver, typename _Sigma>
547 | inline  Automata<_State, _Driver, _Sigma>
548 | Automata<_State, _Driver, _Sigma>::operator|(Automata & ato_)
549 | {
550 | 	auto ato = clone();
551 | 	ato.graph_.sort();
552 | 	ato_.graph_.sort();
553 | 	ato.graph_.merge(ato_.graph_);
554 | 	ato.graph_.unique();
555 | 	auto start = gen_state();
556 | 	auto end = gen_state();
557 | 	ato.add_edge(start, ato.start_, epsilon);
558 | 	ato.add_edge(start, ato_.start_, epsilon);
559 | 	ato.set_start(start);
560 | 	for (auto s : ato.accept_)
561 | 	{
562 | 		ato.add_edge(s, end, epsilon);
563 | 	}
564 | 	for (auto s : ato_.accept_)
565 | 	{
566 | 		ato.add_edge(s, end, epsilon);
567 | 	}
568 | 	ato.accept_.clear();
569 | 	ato.set_accept(end);
570 | 	return ato;
571 | }
572 | 
573 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
574 | ATMPL::optional<typename Automata<_State, _Driver, _Sigma>::State>
575 | Automata<_State, _Driver, _Sigma>::find_state(_State s)
576 | {
577 | 	for (auto g : graph_)
578 | 	{
579 | 		if (g.state_ == s)
580 | 		{
581 | 			return g;
582 | 		}
583 | 	}
584 | 	return ATMPL::optional<typename Automata<_State, _Driver, _Sigma>::State>();
585 | }
586 | 
587 | template<typename _State /*= int*/, typename _Driver /*= char*/, typename _Sigma>
588 | void Automata<_State, _Driver, _Sigma>::add_edge(_State src, _State dest, _Driver d)
589 | {
590 | 	State src_state = add_state(src);
591 | 	State dest_state = add_state(dest);
592 | 	std::pair<_Driver, State> edge = std::pair<_Driver, State>(d, dest_state);
593 | 	src_state.directed_->push_front(edge);
594 | 	src_state.directed_->unique();
595 | }
596 | 
597 | template<typename _State, typename _Driver, typename _Sigma>
598 | inline void Automata<_State, _Driver, _Sigma>::remove_edge(_State src, _State dest, _Driver d)
599 | {
600 | 	auto src_state = find_state(src);
601 | 	auto dest_state = find_state(dest);
602 | 	if (src_state&&dest_state)
603 | 	{
604 | 		std::pair<_Driver, State> edge = std::pair<_Driver, State>(d, dest_state);
605 | 		(*src_state).directed_->remove(edge);
606 | 	}
607 | }
608 | 
609 | template<typename _State, typename _Driver, typename _Sigma>
610 | inline void Automata<_State, _Driver, _Sigma>::set_start(_State s)
611 | {
612 | 	if (!find_state(s))
613 | 	{
614 | 		add_state(s);
615 | 	}
616 | 	start_ = s;
617 | 	cur_state_ = start_;
618 | }
619 | 
620 | template<typename _State, typename _Driver, typename _Sigma>
621 | inline void Automata<_State, _Driver, _Sigma>::set_accept(_State s)
622 | {
623 | 	accept_.insert(s);
624 | }
625 | 
626 | template<typename _State, typename _Driver, typename _Sigma>
627 | inline void Automata<_State, _Driver, _Sigma>::set_accept(typename Automata<_State, _Driver, _Sigma>::state_set s)
628 | {
629 | 	accept_.insert(s.begin(), s.end());
630 | }
631 | 
632 | template<typename _State, typename _Driver, typename _Sigma>
633 | inline void Automata<_State, _Driver, _Sigma>::cancle_accept(_State s)
634 | {
635 | 	if (accept_.find() != accept_.end())
636 | 	{
637 | 		accept_.erase(s);
638 | 	}
639 | 
640 | }
641 | 
642 | template<typename _State, typename _Driver, typename _Sigma>
643 | inline void Automata<_State, _Driver, _Sigma>::
644 | cancle_accept(typename Automata<_State, _Driver, _Sigma>::state_set s)
645 | {
646 | 	for (auto state : s)
647 | 	{
648 | 		cancle_accept(s);
649 | 	}
650 | }
651 | 
652 | template<typename _State, typename _Driver, typename _Sigma>
653 | inline Automata<_State, _Driver, _Sigma>::Automata(Automata && ato_)
654 | {
655 | 	//std::cout << "Move constructors" << std::endl;
656 | 	set_start(ato_.get_start());
657 | 	set_accept(ato_.get_accepts());
658 | 	graph_ = ato_.graph_;
659 | 	sigma_ = ato_.sigma_;
660 | }
661 | 
662 | template<typename _State, typename _Driver, typename _Sigma>
663 | Automata<_State, _Driver, _Sigma> Automata<_State, _Driver, _Sigma>::clone() const
664 | {
665 | 	//std::cout << "clone" << std::endl;
666 | 	Automata<_State, _Driver, _Sigma> ato(sigma_);
667 | 	ato.graph_.clear();
668 | 	for (auto g : graph_)
669 | 	{
670 | 		for (auto drc : (*g.directed_))
671 | 		{
672 | 			ato.add_edge(g.state_, drc.second.state_, drc.first);
673 | 		}
674 | 	}
675 | 	ato.set_start(const_cast<Automata<_State, _Driver, _Sigma>*>(this)->get_start());
676 | 	ato.set_accept(const_cast<Automata<_State, _Driver, _Sigma>*>(this)->get_accepts());
677 | 	return ato;
678 | }
679 | 
680 | template<typename _State, typename _Driver, typename _Sigma>
681 | _State Automata<_State, _Driver, _Sigma>::gen_state()
682 | {
683 | 	auto state = seed_++;
684 | 	if (state == invalid_state)
685 | 	{
686 | 		seed_ = invalid_state + 1;
687 | 		state = seed_;
688 | 	}
689 | 	return state;
690 | }
691 | 
692 | template<typename _State, typename _Driver, typename _Sigma>
693 | _State Automata<_State, _Driver, _Sigma>::seed_ = Automata<_State, _Driver, _Sigma>::invalid_state + 1;
694 | 
695 | template<typename _State, typename _Driver, typename _Sigma>
696 | Automata<_State, _Driver, _Sigma>::Automata(const _Driver& d, _Sigma sigma)
697 | 	:sigma_(sigma)
698 | {
699 | 	//std::cout << "Converting constructor" << std::endl;
700 | 	auto start = gen_state();
701 | 	auto accept = gen_state();
702 | 	set_start(start);
703 | 	set_accept(accept);
704 | 	add_edge(start, accept, d);
705 | }
706 | 
707 | template<typename _State, typename _Driver, typename _Sigma>
708 | inline Automata<_State, _Driver, _Sigma>::Automata(const Automata & ato_)
709 | {
710 | 	//std::cout << "Copy constructors" << std::endl;
711 | 	*this = ato_;
712 | }
713 | 
714 | template<typename _State, typename _Driver, typename _Sigma>
715 | inline  Automata<_State, _Driver, _Sigma> & Automata<_State, _Driver, _Sigma>::operator=(const Automata & ato_)
716 | {
717 | 	//std::cout << "Copy assignment operator" << std::endl;
718 | 	auto ato = ato_.clone();
719 | 	graph_ = ato.graph_;
720 | 	sigma_ = ato_.sigma_;
721 | 	accept_.clear();
722 | 	set_start(const_cast<Automata<_State, _Driver, _Sigma>&>(ato).get_start());
723 | 	set_accept(const_cast<Automata<_State, _Driver, _Sigma>&>(ato).get_accepts());
724 | 	return *this;
725 | }
726 | 


--------------------------------------------------------------------------------
/Automata/FA.cpp:
--------------------------------------------------------------------------------
 1 | #include "FA.h"
 2 | #include <limits>
 3 | 
 4 | std::string FA::alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 5 | 
 6 | FA::FA(const alphabet_type& d)
 7 | 	:ato_(d, alphabet)
 8 | {
 9 | 
10 | }
11 | 
12 | 
13 | FA::~FA()
14 | {
15 | }
16 | 
17 | 
18 | void FA::print(std::string name)
19 | {
20 | 	ato_.print(name);
21 | }
22 | 
23 | bool FA::check(under_type str)
24 | {
25 | 	auto acp = ato_.get_accepts();
26 | 	for (auto i = str.begin(); i != str.end(); ++i)
27 | 	{
28 | 		if (ato_.consume(*i))
29 | 		{
30 | 			if (acp.find(ato_.cur_state()) != acp.end() 
31 | 				&& std::distance(i, str.begin()) == std::distance(--str.end(), str.begin()))
32 | 			{
33 | 				return true;
34 | 			}
35 | 		}
36 | 		else
37 | 		{
38 | 			return false;
39 | 		}
40 | 	}
41 | 	return false;
42 | }
43 | 
44 | void FA::set_alphabet(under_type _alphabet)
45 | {
46 | 	alphabet = _alphabet;
47 | }
48 | 
49 | void FA::alternate_FA(FA _FA)
50 | {
51 | 	ato_ = ato_ | _FA.ato_;
52 | }
53 | 
54 | void FA::concat_FA(FA _FA)
55 | {
56 | 	ato_ = ato_ + _FA.ato_;
57 | }
58 | 
59 | void FA::closure()
60 | {
61 | 	ato_ = ato_.closure();
62 | }
63 | 
64 | void FA::to_mini_DFA()
65 | {
66 | 	determinate();
67 | 	minimize();
68 | }
69 | 
70 | 
71 | void FA::determinate()
72 | {
73 | 	ato_.determinate();
74 | }
75 | 
76 | void FA::minimize()
77 | {
78 | 	ato_.minimize();
79 | }
80 | 


--------------------------------------------------------------------------------
/Automata/FA.h:
--------------------------------------------------------------------------------
 1 | #ifndef FA_h__
 2 | #define FA_h__
 3 | 
 4 | #include <set>
 5 | #include <map>
 6 | #include <type_traits>
 7 | #include <functional>
 8 | #include <utility>
 9 | #include "Automata.h"
10 | #pragma once
11 | class FA
12 | {
13 | public:
14 | 	using state = int;
15 | 	static std::string alphabet;
16 | 	using under_type = decltype(alphabet);
17 | 	using alphabet_type = under_type::value_type;
18 | 	using automata_type = Automata<state, alphabet_type, under_type>;
19 | 
20 | 	explicit FA(const alphabet_type& d);
21 | 	~FA();
22 | 
23 | 	void print(std::string name);
24 | 	bool check(under_type str);
25 | 	static void  set_alphabet(under_type _alphabet);
26 | 
27 | 	//construct NFA
28 | 	void alternate_FA(FA _FA);
29 | 	void concat_FA(FA _FA);
30 | 	void closure();
31 | 
32 | 	void to_mini_DFA();
33 | 	void determinate();
34 | 	void minimize();
35 | 
36 | private:
37 | 	automata_type ato_;
38 | };
39 | 
40 | #endif // FA_h__
41 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.6)
2 | project(ERE)
3 | 
4 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
5 | set(SOURCE_FILES Automata/FA.cpp Automata/Automata.cpp Parser/BREParser.cpp util/Set.cpp ERE.cpp)
6 | add_executable(ERE ${SOURCE_FILES})
7 | target_link_libraries(ERE libboost_program_options-mt.a)


--------------------------------------------------------------------------------
/ERE.cpp:
--------------------------------------------------------------------------------
 1 | #include "util/Set.h"
 2 | #include "Automata//Automata.h"
 3 | #include "Parser/BREParser.h"
 4 | #include "boost/program_options/options_description.hpp"
 5 | #include "boost/program_options/parsers.hpp"
 6 | #include "boost/program_options/variables_map.hpp"
 7 | #include <iostream>
 8 | #include <forward_list>
 9 | #include <cstring>
10 | namespace po = boost::program_options;
11 | void event_handler(BREParser::event e_, ATMPL::any msg_)
12 | {
13 | 	switch (e_)
14 | 	{
15 | 	case BREParser::event::NFA_complete:
16 | 		ATMPL::any::cast<FA>(msg_).print("NFA.dot");
17 | 		break;
18 | 	case BREParser::event::NFA_determinated:
19 | 		ATMPL::any::cast<FA>(msg_).print("DFA.dot");
20 | 		break;
21 | 	case BREParser::event::DFA_minimized:
22 | 		ATMPL::any::cast<FA>(msg_).print("min_DFA.dot");
23 | 		break;
24 | 	}
25 | }
26 | 
27 | int main(int argc, char* argv[])
28 | {
29 | 	po::options_description desc("Allowed options");
30 | 	desc.add_options()
31 | 		("help,h", "produce help message")
32 | 		("expr,e", po::value<std::string>(), "set regular expression")
33 | 		("string,s", po::value<std::string>(), "string to check by regular expression")
34 | 		("alphabet,a", po::value<std::string>()->default_value(FA::alphabet.data()), "set regular expression alphabet");
35 | 	po::variables_map vm;
36 | 	po::store(po::parse_command_line(argc, argv, desc), vm);
37 | 	po::notify(vm);
38 | 	if (vm.count("expr") && vm.count("string"))
39 | 	{
40 | 		try
41 | 		{
42 | 			FA::set_alphabet(vm["alphabet"].as<std::string>().c_str());
43 | 			BREParser bre_parser;
44 | 			bre_parser.register_event(BREParser::event::NFA_complete, event_handler);
45 | 			bre_parser.register_event(BREParser::event::NFA_determinated, event_handler);
46 | 			bre_parser.register_event(BREParser::event::DFA_minimized, event_handler);
47 | 			auto fa = bre_parser.parse(vm["expr"].as<std::string>());
48 | 			if (fa.check(vm["string"].as<std::string>()))
49 | 			{
50 | 				std::cout << "matching!" << std::endl;
51 | 			}
52 | 			else
53 | 			{
54 | 				std::cout << "not matching!" << std::endl;
55 | 			}
56 | 		}
57 | 		catch (std::exception &e)
58 | 		{
59 | 			std::cout << e.what() << std::endl;
60 | 		}
61 | 	}
62 | 	else
63 | 	{
64 | 		std::cout << desc;
65 | 	}
66 | 
67 | }
68 | 
69 | 


--------------------------------------------------------------------------------
/ERE.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="源文件">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="头文件">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="资源文件">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClInclude Include="BREParser.h">
19 |       <Filter>头文件</Filter>
20 |     </ClInclude>
21 |     <ClInclude Include="FA.h">
22 |       <Filter>头文件</Filter>
23 |     </ClInclude>
24 |     <ClInclude Include="Set.h">
25 |       <Filter>头文件</Filter>
26 |     </ClInclude>
27 |     <ClInclude Include="Automata.h">
28 |       <Filter>头文件</Filter>
29 |     </ClInclude>
30 |   </ItemGroup>
31 |   <ItemGroup>
32 |     <ClCompile Include="BREParser.cpp">
33 |       <Filter>源文件</Filter>
34 |     </ClCompile>
35 |     <ClCompile Include="FA.cpp">
36 |       <Filter>源文件</Filter>
37 |     </ClCompile>
38 |     <ClCompile Include="ERE.cpp">
39 |       <Filter>源文件</Filter>
40 |     </ClCompile>
41 |   </ItemGroup>
42 | </Project>


--------------------------------------------------------------------------------
/ERE.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |   </ItemGroup>
 13 |   <PropertyGroup Label="Globals">
 14 |     <ProjectGuid>{86C0F19F-12CE-44A0-BD82-A7221563BFEE}</ProjectGuid>
 15 |     <Keyword>Win32Proj</Keyword>
 16 |     <RootNamespace>RE_Engine</RootNamespace>
 17 |     <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
 18 |     <ProjectName>ERE</ProjectName>
 19 |   </PropertyGroup>
 20 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 21 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 22 |     <ConfigurationType>Application</ConfigurationType>
 23 |     <UseDebugLibraries>true</UseDebugLibraries>
 24 |     <PlatformToolset>v140</PlatformToolset>
 25 |     <CharacterSet>Unicode</CharacterSet>
 26 |   </PropertyGroup>
 27 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 28 |     <ConfigurationType>Application</ConfigurationType>
 29 |     <UseDebugLibraries>false</UseDebugLibraries>
 30 |     <PlatformToolset>v140</PlatformToolset>
 31 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 32 |     <CharacterSet>Unicode</CharacterSet>
 33 |   </PropertyGroup>
 34 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 35 |   <ImportGroup Label="ExtensionSettings">
 36 |   </ImportGroup>
 37 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 38 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 39 |   </ImportGroup>
 40 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 41 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 42 |   </ImportGroup>
 43 |   <PropertyGroup Label="UserMacros" />
 44 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 45 |     <LinkIncremental>true</LinkIncremental>
 46 |     <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);G:\opensource libs\boost_1_62_0;</IncludePath>
 47 |     <LibraryPath>$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);G:\opensource libs\boost_1_62_0\lib32-msvc-14.0;</LibraryPath>
 48 |     <LibraryWPath>$(WindowsSDK_MetadataPath);G:\opensource libs\boost_1_62_0\lib32-msvc-14.0;</LibraryWPath>
 49 |   </PropertyGroup>
 50 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 51 |     <LinkIncremental>false</LinkIncremental>
 52 |     <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);G:\opensource libs\boost_1_62_0;</IncludePath>
 53 |     <LibraryPath>$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);G:\opensource libs\boost_1_62_0\lib32-msvc-14.0;</LibraryPath>
 54 |     <LibraryWPath>$(WindowsSDK_MetadataPath);G:\opensource libs\boost_1_62_0\lib32-msvc-14.0;</LibraryWPath>
 55 |   </PropertyGroup>
 56 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 57 |     <ClCompile>
 58 |       <PrecompiledHeader>
 59 |       </PrecompiledHeader>
 60 |       <WarningLevel>Level3</WarningLevel>
 61 |       <Optimization>Disabled</Optimization>
 62 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 63 |     </ClCompile>
 64 |     <Link>
 65 |       <SubSystem>Console</SubSystem>
 66 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 67 |     </Link>
 68 |   </ItemDefinitionGroup>
 69 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 70 |     <ClCompile>
 71 |       <WarningLevel>Level3</WarningLevel>
 72 |       <PrecompiledHeader>
 73 |       </PrecompiledHeader>
 74 |       <Optimization>MaxSpeed</Optimization>
 75 |       <FunctionLevelLinking>true</FunctionLevelLinking>
 76 |       <IntrinsicFunctions>true</IntrinsicFunctions>
 77 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 78 |       <RuntimeTypeInfo>
 79 |       </RuntimeTypeInfo>
 80 |       <DebugInformationFormat>None</DebugInformationFormat>
 81 |       <DisableLanguageExtensions>true</DisableLanguageExtensions>
 82 |     </ClCompile>
 83 |     <Link>
 84 |       <SubSystem>Console</SubSystem>
 85 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 86 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
 87 |       <OptimizeReferences>true</OptimizeReferences>
 88 |     </Link>
 89 |   </ItemDefinitionGroup>
 90 |   <ItemGroup>
 91 |     <ClCompile Include="Automata\Automata.cpp" />
 92 |     <ClCompile Include="Automata\FA.cpp" />
 93 |     <ClCompile Include="ERE.cpp" />
 94 |     <ClCompile Include="Parser\BREParser.cpp" />
 95 |     <ClCompile Include="util\Set.cpp" />
 96 |   </ItemGroup>
 97 |   <ItemGroup>
 98 |     <ClInclude Include="Automata\Automata.h" />
 99 |     <ClInclude Include="Automata\FA.h" />
100 |     <ClInclude Include="Parser\BREParser.h" />
101 |     <ClInclude Include="util\Set.h" />
102 |   </ItemGroup>
103 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
104 |   <ImportGroup Label="ExtensionTargets">
105 |   </ImportGroup>
106 | </Project>


--------------------------------------------------------------------------------
/ERE.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <ClCompile Include="ERE.cpp" />
 5 |     <ClCompile Include="Parser\BREParser.cpp">
 6 |       <Filter>Parser</Filter>
 7 |     </ClCompile>
 8 |     <ClCompile Include="util\Set.cpp">
 9 |       <Filter>util</Filter>
10 |     </ClCompile>
11 |     <ClCompile Include="Automata\Automata.cpp">
12 |       <Filter>Automata</Filter>
13 |     </ClCompile>
14 |     <ClCompile Include="Automata\FA.cpp">
15 |       <Filter>Automata</Filter>
16 |     </ClCompile>
17 |   </ItemGroup>
18 |   <ItemGroup>
19 |     <Filter Include="Parser">
20 |       <UniqueIdentifier>{86ed5819-5bb7-496c-a427-cb4a0c39ad6e}</UniqueIdentifier>
21 |     </Filter>
22 |     <Filter Include="util">
23 |       <UniqueIdentifier>{9515bada-3a17-4266-99ae-2299b657bff1}</UniqueIdentifier>
24 |     </Filter>
25 |     <Filter Include="Automata">
26 |       <UniqueIdentifier>{9425ca9f-6075-4a9f-9c79-ec244024ac86}</UniqueIdentifier>
27 |     </Filter>
28 |   </ItemGroup>
29 |   <ItemGroup>
30 |     <ClInclude Include="Parser\BREParser.h">
31 |       <Filter>Parser</Filter>
32 |     </ClInclude>
33 |     <ClInclude Include="util\Set.h">
34 |       <Filter>util</Filter>
35 |     </ClInclude>
36 |     <ClInclude Include="Automata\Automata.h">
37 |       <Filter>Automata</Filter>
38 |     </ClInclude>
39 |     <ClInclude Include="Automata\FA.h">
40 |       <Filter>Automata</Filter>
41 |     </ClInclude>
42 |   </ItemGroup>
43 | </Project>


--------------------------------------------------------------------------------
/ERE.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
4 |     <LocalDebuggerCommandArguments> -e "a*|(b|c)*" -s aaaa -a abc</LocalDebuggerCommandArguments>
5 |     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
6 |   </PropertyGroup>
7 | </Project>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 yufeng Z
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Parser/BREParser.cpp:
--------------------------------------------------------------------------------
  1 | #include "BREParser.h"
  2 | #include <algorithm>
  3 | BREParser::BREParser()
  4 | 	:m_pos(-1)
  5 | {
  6 | }
  7 | 
  8 | 
  9 | BREParser::~BREParser()
 10 | {
 11 | }
 12 | 
 13 | FA BREParser::parse(std::string _src)
 14 | {
 15 | 	m_rexpr = _src;
 16 | 	auto fa = RE();
 17 | 	if (m_pos < _src.length()-1)
 18 | 	{
 19 | 		throw BREParserException("abort unexpected at offset:" + std::to_string(m_pos + 1));
 20 | 	}
 21 | 	dispatch(event::NFA_complete, fa);
 22 | 	fa.determinate();
 23 | 	dispatch(event::NFA_determinated, fa);
 24 | 	fa.minimize();
 25 | 	dispatch(event::DFA_minimized, fa);
 26 | 	return fa;
 27 | 
 28 | }
 29 | 
 30 | void BREParser::register_event(event e_, event_handler h_)
 31 | {
 32 | 	event_center_.push_front(std::make_pair(e_, h_));
 33 | }
 34 | 
 35 | void BREParser::dispatch(event e_, ATMPL::any msg_)
 36 | {
 37 | 	for (auto ev : event_center_)
 38 | 	{
 39 | 		if (ev.first == e_)
 40 | 		{
 41 | 			ev.second(e_, msg_);
 42 | 		}
 43 | 	}
 44 | }
 45 | 
 46 | FA BREParser::RE()
 47 | {
 48 | 	return expr();
 49 | }
 50 | 
 51 | FA BREParser::expr()
 52 | {
 53 | 	FA _fa = term();
 54 | 	if (peek_next() == '|')
 55 | 	{
 56 | 		next();
 57 | 		_fa.alternate_FA(expr());
 58 | 	}
 59 | 	return _fa;
 60 | }
 61 | 
 62 | FA BREParser::term()
 63 | {
 64 | 	FA _fa = factor();
 65 | 	while (peek_next() != '|' && peek_next() != ')' && has_next())
 66 | 	{
 67 | 		_fa.concat_FA(factor());
 68 | 	}
 69 | 	return _fa;
 70 | }
 71 | 
 72 | FA BREParser::factor()
 73 | {
 74 | 	FA _fa = item();
 75 | 	while (peek_next() == '*')
 76 | 	{
 77 | 		next();
 78 | 		_fa.closure();
 79 | 	}
 80 | 	return _fa;
 81 | }
 82 | 
 83 | FA BREParser::item()
 84 | {
 85 | 	if (peek_next() == '(')
 86 | 	{
 87 | 		next();
 88 | 		auto _fa = expr();
 89 | 		if (peek_next() != ')')
 90 | 		{
 91 | 			//missing ')'
 92 | 			throw BREParserException(("missing ')' at offset:" + std::to_string(m_pos + 1)).c_str());
 93 | 		}
 94 | 		next();
 95 | 		return _fa;
 96 | 	}
 97 | 	else if (std::find(FA::alphabet.begin(), FA::alphabet.end(),peek_next()) != FA::alphabet.end())
 98 | 	{
 99 | 		return sym();
100 | 	}
101 | 	throw BREParserException(("unknown letter found at offset:" + std::to_string(m_pos + 1)).c_str());
102 | }
103 | 
104 | FA BREParser::sym()
105 | {
106 | 	FA _fa(peek_next());
107 | 	next();
108 | 	return _fa;
109 | }
110 | 
111 | char BREParser::next()
112 | {
113 | 	char _next_char = peek_next();
114 | 	if (_next_char != eof)
115 | 	{
116 | 		++m_pos;
117 | 	}
118 | 	return _next_char;
119 | }
120 | 
121 | char BREParser::peek_next()
122 | {
123 | 	pos next_pos = m_pos + 1;
124 | 	if (next_pos < m_rexpr.length())
125 | 	{
126 | 		return m_rexpr.at(next_pos);
127 | 	}
128 | 	return eof;
129 | }
130 | 
131 | bool BREParser::has_next()
132 | {
133 | 	if (peek_next() != eof)
134 | 	{
135 | 		return true;
136 | 	}
137 | 	return false;
138 | }
139 | 
140 | 


--------------------------------------------------------------------------------
/Parser/BREParser.h:
--------------------------------------------------------------------------------
 1 | #ifndef BREParser_h__
 2 | #define BREParser_h__
 3 | #include <string>
 4 | #include <functional>
 5 | #include <tuple>
 6 | #include <type_traits>
 7 | #include <exception>
 8 | #include "../third_part/ATMPL/any/any.hpp"
 9 | #include "../Automata/FA.h"
10 | #pragma once
11 | class BREParser
12 | {
13 | public:
14 | 	BREParser();
15 | 	~BREParser();
16 | 	FA parse(std::string _src);
17 | 	class BREParserException :public std::exception
18 | 	{
19 | 	public:
20 | 		BREParserException(std::string msg):msg_(msg){}
21 | 		virtual const char* what() const noexcept
22 | 		{
23 | 			return msg_.c_str();
24 | 		}
25 | 	private:
26 | 		std::string msg_;
27 | 	};
28 | 	enum event
29 | 	{
30 | 		NFA_complete,
31 | 			NFA_determinated,
32 | 			DFA_minimized
33 | 	};
34 | 	using event_handler = std::function<void(event, ATMPL::any)>;
35 | 	void register_event(event e_, event_handler h_);
36 | private:
37 | 	void dispatch(event e_, ATMPL::any msg_);
38 | private:
39 | 	//note: the current letter view as processed.
40 | 	FA RE();
41 | 	FA expr();
42 | 	FA term();
43 | 	FA factor();
44 | 	FA item();
45 | 	FA sym();
46 | 
47 | 	//move one step forward.
48 | 	//return eof = '\0' if no next letter.
49 | 	char next();
50 | 
51 | 	//get next letter but not move forward.
52 | 	//return eof = '\0' if no next letter.
53 | 	char peek_next();
54 | 
55 | 	bool has_next();
56 | 
57 | 	using pos = unsigned int;
58 | 	char eof = '\0';
59 | 
60 | 	std::string m_rexpr;
61 | 	pos m_pos;
62 | 
63 | 	std::forward_list<std::pair<event, event_handler>> event_center_;
64 | 
65 | };
66 | #endif // BREParser_h__
67 | 
68 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ERE
 2 | **Educational Regular expression Engine--purpose for education of automata theory.**
 3 | 
 4 | all base on C++11 standard library and a tiny C++11 template library [ATMPL](https://github.com/yufengzjj/ATMPL) .
 5 | 
 6 | this regular expression engine only support core operations:alternate,concat and closure.
 7 | 
 8 | it uses recursive descent parsing to parse regular expression and then generate finite state automata.it can generate DOT(Graphviz) file of NFA/DFA/miniDFA of the regular expression automata.
 9 | 
10 | examples:
11 | 
12 | > ERE.exe --help
13 | >
14 | > -h [ --help ] produce help message
15 | >
16 | > -e [ --expr ] arg set regular expression
17 | >
18 | > -s [ --string ] arg string to check by regular expression
19 | >
20 | > -a [ --alphabet ] arg set regular expression alphabet
21 | 
22 | ERE.exe -e "a(b|cd)*e" -s abbbcdcde
23 | 
24 | ![](doc/1.png)
25 | 
26 | dot -T png -O NFA.dot DFA.dot min_DFA.dot
27 | 
28 | 
29 | 
30 | ![](doc/NFA.dot.png)
31 | 
32 | ![](doc/DFA.dot.png)
33 | 
34 | ![](doc/min_DFA.dot.png)


--------------------------------------------------------------------------------
/doc/1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yufengzjj/ERE/5c62b344472754dc67b75038de7193e653e1e37d/doc/1.png


--------------------------------------------------------------------------------
/doc/DFA.dot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yufengzjj/ERE/5c62b344472754dc67b75038de7193e653e1e37d/doc/DFA.dot.png


--------------------------------------------------------------------------------
/doc/NFA.dot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yufengzjj/ERE/5c62b344472754dc67b75038de7193e653e1e37d/doc/NFA.dot.png


--------------------------------------------------------------------------------
/doc/min_DFA.dot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yufengzjj/ERE/5c62b344472754dc67b75038de7193e653e1e37d/doc/min_DFA.dot.png


--------------------------------------------------------------------------------
/third_part/ATMPL/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 yufeng Z
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/third_part/ATMPL/README.md:
--------------------------------------------------------------------------------
 1 | # ATMPL
 2 | 
 3 | **all library components write in c++11 without any other dependency.**
 4 | 
 5 | at present, this ATMPL--Another Template Meta Programming Library has a little supported  
 6 | 
 7 | features as follow:  
 8 | 
 9 | ### functional_helper  
10 | include function traits and a enhanced bind template class.  
11 | 
12 | ### Any
13 | 
14 | Safe, generic container for single values of different value types. **similar to [boost.Any](http://www.boost.org/doc/libs/1_60_0/doc/html/any.html)** but c++11 version.
15 | 
16 | ### Optional
17 | 
18 | A value-semantic, type-safe wrapper for representing 'optional' (or 'nullable') objects of a given type. An optional object may or may not contain a value of the underlying type. [boost.Optional](http://www.boost.org/doc/libs/1_61_0/libs/optional/doc/html/index.html) C++11 version
19 | 
20 | **all test on VS2015/GCC 5.3.0/Clang 3.8.0**
21 | 
22 | 


--------------------------------------------------------------------------------
/third_part/ATMPL/any/any.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | // Created by bhzyf on 2016/5/2.
  3 | //
  4 | 
  5 | #ifndef CLIONSCIENCE_ANY_HPP
  6 | #define CLIONSCIENCE_ANY_HPP
  7 | #include <type_traits>
  8 | #include <typeinfo>
  9 | 
 10 | namespace ATMPL
 11 | {
 12 | 	class any
 13 | 	{
 14 | 	private:
 15 | 		class placeholder
 16 | 		{
 17 | 		public: // structors
 18 | 
 19 | 			virtual ~placeholder()
 20 | 			{
 21 | 			}
 22 | 
 23 | 		public: // queries
 24 | 
 25 | 			virtual placeholder *clone() const = 0;
 26 | 
 27 | 		};
 28 | 
 29 | 		template<typename _ValueType>
 30 | 		class holder : public placeholder
 31 | 		{
 32 | 		public:
 33 | 			holder(const _ValueType &v)
 34 | 				: _hold(v)
 35 | 			{
 36 | 			}
 37 | 
 38 | 			placeholder *clone() const override
 39 | 			{
 40 | 				return new holder(_hold);
 41 | 			}
 42 | 
 43 | 		public:
 44 | 			_ValueType _hold;
 45 | 		};
 46 | 
 47 | 	public:
 48 | 		any() : _holder(nullptr)
 49 | 		{
 50 | 		}
 51 | 
 52 | 		template<typename _ValueType>
 53 | 		any(const _ValueType &v)
 54 | 			: _holder(new holder<typename std::remove_cv<typename std::decay<const _ValueType>::type>::type>(v))
 55 | 		{
 56 | 		}
 57 | 
 58 | 		// Perfect forwarding of _ValueType
 59 | 		template<typename _ValueType>
 60 | 		any(_ValueType &&v
 61 | 			, typename std::enable_if<!std::is_same<any, typename std::decay<_ValueType>::type>::value, _ValueType>::type* = nullptr
 62 | 			, typename std::enable_if<!std::is_const<_ValueType>::value>::type* = nullptr)
 63 | 			:_holder(new holder< typename std::decay<_ValueType>::type >(std::forward<_ValueType>(v)))
 64 | 		{
 65 | 		}
 66 | 
 67 | 		//copy constructor
 68 | 		any(const any &other)
 69 | 			: _holder(other._holder != nullptr ? other._holder->clone() : nullptr)
 70 | 		{
 71 | 		}
 72 | 
 73 | 		//move constructor
 74 | 		any(any && other)
 75 | 			:_holder(other._holder)
 76 | 		{
 77 | 			other._holder = nullptr;
 78 | 		}
 79 | 
 80 | 		//assignment constructor
 81 | 		any & operator=(const any& other_any)
 82 | 		{
 83 | 			_holder = other_any._holder->clone();
 84 | 			return *this;
 85 | 		}
 86 | 
 87 | 		//move assignment constructor 
 88 | 		any & operator=(any&& other_any)
 89 | 		{
 90 | 			_holder = other_any._holder;
 91 | 			other_any._holder = nullptr;
 92 | 			return *this;
 93 | 		}
 94 | 
 95 | 		~any()
 96 | 		{
 97 | 			delete _holder;
 98 | 			_holder = nullptr;
 99 | 		}
100 | 
101 | 		template<typename _ValueType>
102 | 		static _ValueType cast(any &operand)
103 | 		{
104 | 			typedef typename std::remove_reference<_ValueType>::type nonref;
105 | 			nonref * op = cast<nonref>(&operand);
106 | 			typedef typename std::conditional<std::is_reference<_ValueType>::value, _ValueType,
107 | 				typename std::add_lvalue_reference<_ValueType>::type>::type ref_type;
108 | 			return static_cast<ref_type>(*op);
109 | 		}
110 | 
111 | 	private:
112 | 		template<typename _ValueType>
113 | 		static _ValueType *cast(any *operand)
114 | 		{
115 | 			auto _holder = dynamic_cast<holder<_ValueType> *>(operand->_holder);
116 | 			if (_holder == nullptr)
117 | 				throw std::bad_cast();
118 | 			return &_holder->_hold;
119 | 		}
120 | 
121 | 		template<typename _ValueType>
122 | 		static const _ValueType *cast(const any *operand)
123 | 		{
124 | 			return cast<_ValueType>(const_cast<any *>(operand));
125 | 		}
126 | 
127 | 
128 | 	public:
129 | 		placeholder *_holder;
130 | 	};
131 | 
132 | 
133 | }
134 | #endif //CLIONSCIENCE_ANY_HPP
135 | 


--------------------------------------------------------------------------------
/third_part/ATMPL/any/readme.md:
--------------------------------------------------------------------------------
 1 | examples:
 2 | 
 3 | ```c++
 4 | #include <iostream>
 5 | #include <string>
 6 | #include "any.hpp"
 7 | #include <vector>
 8 | using namespace ATMPL;
 9 | 
10 | template<typename _T>
11 | void pod_test(any &v)
12 | {
13 |     std::cout << "any cast to " << typeid(_T).name() << " : " << any::cast<_T>(v) << std::endl;
14 | }
15 | 
16 | any ret()
17 | {
18 |     int i = 1;
19 |     return any(i);
20 | }
21 | 
22 | int main()
23 | {
24 | 
25 | 
26 |     try
27 |     {
28 |         any v(short(1));
29 |         pod_test<short>(v);
30 | 
31 |         any v_int(int(2));
32 |         pod_test<int>(v_int);
33 | 
34 |         any v_long(long(3));
35 |         pod_test<long>(v_long);
36 | 
37 |         any v_longlong((long long)(4));
38 |         pod_test<long long>(v_longlong);
39 | 
40 |         any v_char(char('5'));
41 |         pod_test<char>(v_char);
42 | 
43 |         char str[] = "hello world";
44 |         any v_cptr(str);
45 |         pod_test<char const *>(v_cptr);
46 | 
47 |         any v_string(std::string("HI! string any cast"));
48 |         pod_test<std::string>(v_string);
49 | 
50 |         any any_0;
51 |         any any_1(ret());
52 |         pod_test<int>(any_1);
53 | 
54 |         any any_2(any_1);
55 |         pod_test<int>(any_2);
56 | 
57 |         any any_3 = ret();
58 |         pod_test<int>(any_3);
59 | 
60 |         any any_4 = any_1;
61 |         pod_test<int>(any_4);
62 | 
63 |         any any_5 = any(int(5));
64 |         pod_test<int>(any_5);
65 | 
66 |         std::vector<any> any_vec;
67 |         any_vec.push_back('A');
68 |         any_vec.push_back(short(1));
69 |         any_vec.push_back(int(2));
70 |         any_vec.push_back(str);
71 |         any_vec.push_back(std::string("hello any,world"));
72 |         pod_test<char>(any_vec[0]);
73 |         pod_test<short>(any_vec[1]);
74 |         pod_test<int>(any_vec[2]);
75 |         pod_test<char const *>(any_vec[3]);
76 |         pod_test<std::string>(any_vec[4]);
77 | 
78 |         printf("test passed\n");
79 |     }
80 |     catch (std::bad_cast&e)
81 |     {
82 |         std::cout << e.what()<<" occured when use any\n";
83 |     }
84 | 
85 | 
86 | }
87 | ```


--------------------------------------------------------------------------------
/third_part/ATMPL/any/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include "any.hpp"
 4 | #include <vector>
 5 | using namespace ATMPL;
 6 | 
 7 | template<typename _T>
 8 | void pod_test(any &v)
 9 | {
10 |     std::cout << "any cast to " << typeid(_T).name() << " : " << any::cast<_T>(v) << std::endl;
11 | }
12 | 
13 | any ret()
14 | {
15 |     int i = 1;
16 |     return any(i);
17 | }
18 | 
19 | int main()
20 | {
21 | 
22 | 
23 |     try
24 |     {
25 |         any v(short(1));
26 |         pod_test<short>(v);
27 | 
28 |         any v_int(int(2));
29 |         pod_test<int>(v_int);
30 | 
31 |         any v_long(long(3));
32 |         pod_test<long>(v_long);
33 | 
34 |         any v_longlong((long long)(4));
35 |         pod_test<long long>(v_longlong);
36 | 
37 |         any v_char(char('5'));
38 |         pod_test<char>(v_char);
39 | 
40 |         char str[] = "hello world";
41 |         any v_cptr(str);
42 |         pod_test<char const *>(v_cptr);
43 | 
44 |         any v_string(std::string("HI! string any cast"));
45 |         pod_test<std::string>(v_string);
46 | 
47 |         any any_0;
48 |         any any_1(ret());
49 |         pod_test<int>(any_1);
50 | 
51 |         any any_2(any_1);
52 |         pod_test<int>(any_2);
53 | 
54 |         any any_3 = ret();
55 |         pod_test<int>(any_3);
56 | 
57 |         any any_4 = any_1;
58 |         pod_test<int>(any_4);
59 | 
60 |         any any_5 = any(int(5));
61 |         pod_test<int>(any_5);
62 | 
63 |         std::vector<any> any_vec;
64 |         any_vec.push_back('A');
65 |         any_vec.push_back(short(1));
66 |         any_vec.push_back(int(2));
67 |         any_vec.push_back(str);
68 |         any_vec.push_back(std::string("hello any,world"));
69 |         pod_test<char>(any_vec[0]);
70 |         pod_test<short>(any_vec[1]);
71 |         pod_test<int>(any_vec[2]);
72 |         pod_test<char const *>(any_vec[3]);
73 |         pod_test<std::string>(any_vec[4]);
74 | 
75 |         printf("test passed\n");
76 |     }
77 |     catch (std::bad_cast&e)
78 |     {
79 |         std::cout << e.what()<<" occured when use any\n";
80 |     }
81 | 
82 | 
83 | }


--------------------------------------------------------------------------------
/third_part/ATMPL/functinal_helper/bind.hpp:
--------------------------------------------------------------------------------
  1 | #include <tuple>
  2 | #include <type_traits>
  3 | #include <functional>
  4 | #include "func_traits.hpp"
  5 | namespace ATMPL
  6 | {
  7 |     
  8 | 
  9 | namespace functional_helper
 10 | {
 11 |     template<class BindExpr, class F, class...Args>
 12 |     struct bind_holder;
 13 | 
 14 |     template<class F>
 15 |     struct is_bind_holder
 16 |         :public std::false_type
 17 |     {};
 18 |     template<class BindExpr, class F, class...Args>
 19 |     struct is_bind_holder<bind_holder<BindExpr,F,Args...>>
 20 |         :public std::true_type
 21 |     {};
 22 | 
 23 |     template<class BindExpr, class F, class...Args>
 24 |     struct is_bind_holder<const bind_holder<BindExpr, F, Args...>>
 25 |         :public std::true_type
 26 |     {};
 27 | 
 28 |     template<class BindExpr, class F, class...Args>
 29 |     struct is_bind_holder<volatile bind_holder<BindExpr, F, Args...>>
 30 |         :public std::true_type
 31 |     {};
 32 | 
 33 |     template<class BindExpr, class F, class...Args>
 34 |     struct is_bind_holder<const volatile bind_holder<BindExpr, F, Args...>>
 35 |         :public std::true_type
 36 |     {};
 37 | 
 38 |     
 39 | 
 40 |     template<class F,bool Is_bind_holder>
 41 |     struct bind_holder_stripper_helper;
 42 | 
 43 |     template<class F>
 44 |     struct bind_holder_stripper_helper<F, false>
 45 |         : public func_traits<F>
 46 |     {};
 47 |     
 48 |     template<class F>
 49 |     struct bind_holder_stripper_helper<F, true>
 50 |         :public bind_holder_stripper_helper<typename F::bind_type, is_bind_holder<typename F::bind_type>::value>
 51 |     {};
 52 | 
 53 |     template<class F>
 54 |     struct bind_holder_stripper
 55 |         :public bind_holder_stripper_helper<F, is_bind_holder<F>::value>
 56 |     {};
 57 | 
 58 |     template<class BindExpr, class F, class...Args>
 59 |     struct bind_holder
 60 |     {
 61 |     private:
 62 |         BindExpr _bind_expr;
 63 |     public:
 64 | 
 65 |         typedef F bind_type;
 66 |         typedef bind_holder_stripper<F> underlying_type;
 67 |         typedef std::integral_constant<size_t, sizeof...(Args)> bind_arity;
 68 |         explicit bind_holder(BindExpr&& _functor)
 69 |             :_bind_expr(std::move(std::forward<BindExpr>(_functor)))
 70 |         {
 71 |         }
 72 | 
 73 |         template<size_t N>
 74 |         struct bind_arg
 75 |         {
 76 |             static_assert(N < bind_arity::value, "error: invalid parameter index.");
 77 |             using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
 78 |         };
 79 | 
 80 |         template<typename... _Args>
 81 |         auto operator()(_Args&&...params)
 82 |             ->decltype(this->_bind_expr(std::forward<_Args>(params)...))
 83 |         {
 84 |             return this->_bind_expr(std::forward<_Args>(params)...);
 85 |         }
 86 |     };
 87 | 
 88 | 	template <typename T>
 89 | 	struct remove_cvr
 90 | 	{
 91 | 		using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 92 | 	};
 93 | 
 94 |     template<class F, typename...Args>
 95 |     auto bind(F&& f, Args&&... args)
 96 |         ->decltype((bind_holder<decltype(std::bind(std::forward<F>(f), std::forward<Args>(args)...)),
 97 |         typename remove_cvr<F>::type, Args...>
 98 |                 (std::bind(std::forward<F>(f), std::forward<Args>(args)...))))
 99 |     {
100 |         return (bind_holder<decltype(std::bind(std::forward<F>(f), std::forward<Args>(args)...)),
101 |             typename remove_cvr<F>::type, Args...>
102 |                         (std::bind(std::forward<F>(f), std::forward<Args>(args)...)));
103 |     }
104 | }
105 | 
106 | }


--------------------------------------------------------------------------------
/third_part/ATMPL/functinal_helper/func_traits.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <tuple>
 3 | #include <type_traits>
 4 | 
 5 | namespace ATMPL
 6 | {
 7 | 
 8 | 	namespace functional_helper
 9 | 	{
10 | 		template<typename _T>
11 | 		struct func_traits;
12 | 
13 | 		//function
14 | 		template<typename _Ret, typename... _Args>
15 | 		struct  func_traits<_Ret(_Args...)>
16 | 		{
17 | 			typedef _Ret ret;
18 | 			typedef std::integral_constant<size_t, sizeof...(_Args)> arity;
19 | 			template<size_t N>
20 | 			struct arg
21 | 			{
22 | 				static_assert(N < arity::value, "invalid parameter index");
23 | 				using type = typename std::tuple_element<N, std::tuple<_Args...>>::type;
24 | 			};
25 | 		};
26 | 
27 | 		//function pointer
28 | 		template<typename _Ret, typename... _Args>
29 | 		struct  func_traits<_Ret(*)(_Args...)> :public func_traits<_Ret(_Args...)>
30 | 		{
31 | 		};
32 | 
33 | 		//member function pointer
34 | 		template<typename _Ret, class _Class, typename... _Args>
35 | 		struct  func_traits<_Ret(_Class::*)(_Args...)> :public func_traits<_Ret(_Class&, _Args...)>
36 | 		{
37 | 		};
38 | 
39 | 		template<typename _Ret, class _Class, typename... _Args>
40 | 		struct  func_traits<_Ret(_Class::*)(_Args...) const> :public func_traits<_Ret(_Class&, _Args...)>
41 | 		{
42 | 		};
43 | 
44 | 
45 | 		//functor and lambda
46 | 		template<class _Class>
47 | 		struct  func_traits : public func_traits<decltype(&_Class::operator())>
48 | 		{
49 | 		};
50 | 
51 | 	}
52 | 
53 | 
54 | }


--------------------------------------------------------------------------------
/third_part/ATMPL/functinal_helper/readme.md:
--------------------------------------------------------------------------------
 1 | ### functional_helper
 2 | 
 3 | include function traits and a enhanced bind template class.  
 4 | 
 5 | ##### function_traits
 6 | 
 7 |  it provide a template class named function_traits<template T>. 
 8 | you can obtain type information on compile-time like return type, 
 9 | arguments' type. it support function pointer,member function pointer, 
10 | member object pointer,lambda and functor.(no support for bind expression,see next).  
11 | 
12 | ##### bind--enhanced std::bind
13 | 
14 |  this version of bind also supports whatever std::bind supports for binding. 
15 | it allow you obtain type information of the bonded callable objects as function_traits provided. 
16 | bind::underlying_type is the very original callable type. it can obtain very original callable type information 
17 | of any recursive bind(not std::bind) you have made.  
18 | 
19 |   
20 | 
21 | all of it programmed with standard c++11. 
22 | this library supports any compilers as long as they support c++11 standard.
23 | 
24 |   
25 | 
26 | examples:
27 | 
28 | ```c++ 
29 | void test(int,char*){}
30 | auto f1 = functional_helper::bind(test, _1,_2);
31 | auto f2 = functional_helper::bind(f1, _1, _2);
32 | auto test_lambda = [](int, char*)->void{};
33 | ```
34 | 
35 | obtain argument: 
36 | 
37 | ```c++
38 | functional_helper::function_traits<decltype(test)>::arg<1>::type//char*
39 | decltype(f1)::underlying_type::arg<1>::type //char*
40 | decltype(f2)::underlying_type::arg<1>::type //char*
41 | decltype(test_lambda)::underlying_type::arg<1>::type //char*
42 | f1('A');
43 | f2('B');
44 | test_lambda(1,'C');
45 | ```
46 | 
47 | 


--------------------------------------------------------------------------------
/third_part/ATMPL/functinal_helper/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <type_traits>
 2 | #include <functional>
 3 | #include "bind.hpp"
 4 | using namespace ATMPL::functional_helper;
 5 | int test(int, long*)
 6 | {
 7 | 	return 0;
 8 | }
 9 | class test_class
10 | {
11 | public:
12 |     test_class(){}
13 |     ~test_class(){}
14 |     void test(int, char*){}
15 | };
16 | using namespace std::placeholders;
17 | using namespace ATMPL;
18 | void bind_holder_test()
19 | {
20 | 	auto f1 = functional_helper::bind(test, _1, _2);
21 | 	auto f2 = functional_helper::bind(f1, _1, _2);
22 | 	auto f3 = functional_helper::bind(f1, _1, _2);
23 | 	f1(1, nullptr);
24 | 	f2(1, nullptr);
25 | 	f3(1, nullptr);
26 | 	static_assert(std::is_same<decltype(f1), decltype(f2)::bind_type>::value, "");
27 | 	static_assert(std::is_same<decltype(f1)::underlying_type::arg<1>::type, long*>::value, "");
28 | 	static_assert(std::is_same<bind_holder_stripper<decltype(f3)>::arg<1>::type, long*>::value, "");
29 | 	static_assert(std::is_same<bind_holder_stripper<decltype(f3)>::arg<1>::type, decltype(f3)::underlying_type::arg<1>::type>::value, "");
30 | }
31 | 
32 | 
33 | class T
34 | {
35 | public:
36 | 	short test(long) const
37 | 	{
38 | 		return 1;
39 | 	}
40 | 	static void test1(char) {}
41 | 	long long operator() (int) const
42 | 	{
43 | 		return 1;
44 | 	}
45 | };
46 | 
47 | void function_traits_test()
48 | {
49 | 	T t;
50 | 	auto p = [](int, const char*, long*)->int {
51 | 		return 0;
52 | 	};
53 | 	auto bind_func = std::bind(test, 1, std::placeholders::_1, std::placeholders::_2);
54 | 	typedef decltype(&T::test)  mem_func_pointer;
55 | 	typedef decltype(test)  func;
56 | 	typedef decltype(&test)  func_pointer;
57 | 	typedef decltype(t)  functor;
58 | 	typedef decltype(p)  lambda_type;
59 | 	typedef decltype(&lambda_type::operator())  lambda;
60 | 	typedef decltype(bind_func) bind_expr;
61 | 	printf("%s\n", typeid(func_traits<mem_func_pointer>::arg<1>::type).name());
62 | 	printf("%s\n", typeid(func_traits<func>::ret).name());
63 | 	printf("%s\n", typeid(func_traits<func_pointer>::arg<0>::type).name());
64 | 	printf("%s\n", typeid(func_traits<functor>::arg<1>::type).name());
65 | 	printf("%s\n", typeid(func_traits<lambda>::arg<2>::type).name());
66 | 	printf("%s\n", typeid(func_traits<lambda_type>::arg<3>::type).name());
67 | 	printf("%s\n", typeid(lambda_type).name());
68 | 	printf("%s\n", typeid(lambda).name());
69 | 	printf("%s\n", typeid(bind_expr).name());
70 | 
71 | 
72 | 
73 | 	static_assert(std::is_same<func_traits<mem_func_pointer>::arg<1>::type, long>::value, "");
74 | 	static_assert(std::is_same<func_traits<func>::ret, int>::value, "");
75 | 	static_assert(std::is_same<func_traits<func_pointer>::arg<0>::type, int>::value, "");
76 | 	static_assert(std::is_same<func_traits<functor>::arg<1>::type, int>::value, "");
77 | 	static_assert(std::is_same<func_traits<lambda>::arg<2>::type, const char*>::value, "");
78 | }


--------------------------------------------------------------------------------
/third_part/ATMPL/optional/optional.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | #include <typeinfo>
 4 | namespace ATMPL
 5 | {
 6 | 	template<typename _T>
 7 | 	class optional
 8 | 	{
 9 | 	private:
10 | 		typedef typename std::decay<_T>::type storage_type;
11 | 		typename std::aligned_storage<sizeof(storage_type), alignof(storage_type)>::type storage;
12 | 		bool initialized;
13 | 	public:
14 | 		optional()
15 | 			:initialized(false) {}
16 | 
17 | 		optional(storage_type value)
18 | 		{
19 | 			//std::cout << "convertion\n";
20 | 			::new (&storage) storage_type(std::forward<storage_type>(value));
21 | 			initialized = true;
22 | 		}
23 | 
24 | 		optional(const optional& opl)
25 | 		{
26 | 			//std::cout << "copy constructor\n";
27 | 			initialized = opl.initialized;
28 | 			if (initialized)
29 | 				::new(&storage) storage_type(*opl);
30 | 		}
31 | 
32 | 		optional(optional&& opl)
33 | 		{
34 | 			//std::cout << "move constructor\n";
35 | 			initialized = opl.initialized;
36 | 			if (initialized)
37 | 				::new(&storage) storage_type(std::move(*opl));
38 | 		}
39 | 
40 | 		optional& operator=(optional && opl)
41 | 		{
42 | 			//std::cout << "asign move\n";
43 | 			if (this == &opl)
44 | 				return *this;
45 | 			initialized = opl.initialized;
46 | 			if (initialized)
47 | 				::new(&storage) storage_type(std::move(*opl));
48 | 			return *this;
49 | 		}
50 | 
51 | 		optional& operator=(const optional & opl)
52 | 		{
53 | 			//std::cout << "asign copy\n";
54 | 			if (this == &opl)
55 | 				return *this;
56 | 			initialized = opl.initialized;
57 | 			if (initialized)
58 | 				::new(&storage) storage_type(*const_cast<optional &>(opl));
59 | 			return *this;
60 | 		}
61 | 
62 | 		explicit  operator bool() const
63 | 		{
64 | 			return initialized;
65 | 		}
66 | 
67 | 		bool operator !() const
68 | 		{
69 | 			return !initialized;
70 | 		}
71 | 
72 | 		storage_type operator *() const
73 | 		{
74 | 			return reinterpret_cast<const storage_type&>(storage);
75 | 		}
76 | 
77 | 		template<typename _Type>
78 | 		operator optional<_Type>() const
79 | 		{
80 | 			return static_cast<_Type>(reinterpret_cast<const storage_type&>(storage));
81 | 		}
82 | 
83 | 		template<typename _Type>
84 | 		operator _Type() const
85 | 		{
86 | 			return static_cast<_Type>(reinterpret_cast<const storage_type&>(storage));
87 | 		}
88 | 	};
89 | }


--------------------------------------------------------------------------------
/third_part/ATMPL/optional/optional_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "optional.hpp"
 3 | ATMPL::optional<int> optional_ret()
 4 | {
 5 | 	ATMPL::optional<int> a(15);
 6 | 	return a;
 7 | }
 8 | int optional_test()
 9 | {
10 | 	//constructor test
11 | 	ATMPL::optional<int> explicit_conv_T(12);
12 | 	ATMPL::optional<int> copy_constr(explicit_conv_T);
13 | 	ATMPL::optional<int> move_constr(optional_ret());
14 | 	ATMPL::optional<int> asign_copy;
15 | 	asign_copy = move_constr;
16 | 	ATMPL::optional<int> asign_move;
17 | 	asign_move = optional_ret();
18 | 
19 | 	//cast test
20 | 	ATMPL::optional<int> int_ = 1;
21 | 	int_ = 'f';
22 | 	ATMPL::optional<char> char_ = 's';
23 | 	int_ = char_;
24 | 	std::cout << *int_<<"\n";
25 | 	return 0;
26 | }


--------------------------------------------------------------------------------
/third_part/ATMPL/optional/readme.md:
--------------------------------------------------------------------------------
 1 | examples:
 2 | 
 3 | ```c++
 4 | ATMPL::optional<int> int_;
 5 | if(int_)
 6 |   std::cout<<*int_;//it woulnd not get here!
 7 | int_ = 'f';
 8 | ATMPL::optional<char> char_ = 's';
 9 | int_ = char_;
10 | std::cout << *int_<<"\n";
11 | ```


--------------------------------------------------------------------------------
/util/Set.cpp:
--------------------------------------------------------------------------------
1 | #include "Set.h"
2 | 
3 | 


--------------------------------------------------------------------------------
/util/Set.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <set>
 3 | #include <initializer_list>
 4 | #include <algorithm>
 5 | #include <vector>
 6 | #include <utility>
 7 | template<typename _T>
 8 | class Set : public std::set<_T>
 9 | {
10 | public:
11 | 	Set() {}
12 | 	Set(_T&& x) { std::set<_T>::insert(std::forward<_T>(x)); }
13 | 	Set(const _T& x) { std::set<_T>::insert(x); }
14 | 	Set(const Set& x) :std::set<_T>(x) {}
15 | 	Set(Set&& x) :std::set<_T>(std::forward<Set>(x)) {}
16 | 	Set(std::initializer_list<_T> il) :std::set<_T>(il) {}
17 | 	template <class InputIterator>
18 | 	Set(InputIterator first, InputIterator last)
19 | 		: std::set<_T>(first, last) {}
20 | 
21 | 	Set & operator= (Set &&x)
22 | 	{
23 | 		std::set<_T>::operator =(std::forward<Set>(x));
24 | 		return *this;
25 | 	}
26 | 
27 | 	//set operators
28 | 	Set operator&(Set const& s);
29 | 	Set operator-(Set const& s);
30 | 	Set operator|(Set const& s);
31 | };
32 | 
33 | 
34 | template <typename _T>
35 | Set<_T> Set<_T>::operator&(Set const& s)
36 | {
37 | 	std::vector<_T> r;
38 | 	r.resize(this->size() + s.size());
39 | 	auto it = std::set_intersection(this->begin(), this->end(),
40 | 		s.begin(), s.end(), r.begin());
41 | 	r.resize(it - r.begin());
42 | 	return Set<_T>(r.begin(), r.end());
43 | }
44 | 
45 | template <typename _T>
46 | Set<_T> Set<_T>::operator-(Set const& s)
47 | {
48 | 	std::vector<_T> r;
49 | 	r.resize(this->size() + s.size());
50 | 	auto it = std::set_difference(this->begin(),
51 | 		this->end(), s.begin(), s.end(), r.begin());
52 | 	r.resize(it - r.begin());
53 | 	return Set<_T>(r.begin(), r.end());
54 | }
55 | 
56 | template <typename _T>
57 | Set<_T> Set<_T>::operator|(Set const& s)
58 | {
59 | 	std::vector<_T> r;
60 | 	r.resize(this->size() + s.size());
61 | 	auto it = std::set_union(this->begin(), this->end(),
62 | 		s.begin(), s.end(), r.begin());
63 | 	r.resize(it - r.begin());
64 | 	return Set<_T>(r.begin(), r.end());
65 | }
66 | 


--------------------------------------------------------------------------------