Commit b314fe9d9e17aa2ed2c4b24739ff8156717e7948
1 parent
0b045fe6
- pierwszy commit
git-svn-id: svn://svn.nlp.ipipan.waw.pl/morfeusz/morfeusz@2 ff4e3ee1-f430-4e82-ade0-24591c43f1fd
Showing
26 changed files
with
1195 additions
and
0 deletions
CMakeLists.txt
0 → 100644
1 | +# The name of our project is "HELLO". CMakeLists files in this project can | ||
2 | +# refer to the root source directory of the project as ${HELLO_SOURCE_DIR} and | ||
3 | +# to the root binary directory of the project as ${HELLO_BINARY_DIR}. | ||
4 | +cmake_minimum_required (VERSION 2.6) | ||
5 | +project (Morfeusz) | ||
6 | + | ||
7 | +# Recurse into the "Hello" and "Demo" subdirectories. This does not actually | ||
8 | +# cause another cmake executable to run. The same process will walk through | ||
9 | +# the project's entire directory structure. | ||
10 | +add_subdirectory (fsa) | ||
11 | +add_subdirectory (morfeusz) | ||
12 | + |
fsa/CMakeLists.txt
0 → 100644
fsa/_simple_fsa_impl.hpp
0 → 100644
1 | +/* | ||
2 | + * File: _simple_fsa_impl.hpp | ||
3 | + * Author: mlenart | ||
4 | + * | ||
5 | + * Created on October 20, 2013, 12:25 PM | ||
6 | + */ | ||
7 | + | ||
8 | +#ifndef _SIMPLE_FSA_IMPL_HPP | ||
9 | +#define _SIMPLE_FSA_IMPL_HPP | ||
10 | + | ||
11 | +#include <algorithm> | ||
12 | +#include <utility> | ||
13 | +#include <iostream> | ||
14 | +#include "fsa.hpp" | ||
15 | + | ||
16 | +using namespace std; | ||
17 | + | ||
18 | +#pragma pack(push) /* push current alignment to stack */ | ||
19 | +#pragma pack(1) /* set alignment to 1 byte boundary */ | ||
20 | + | ||
21 | +struct StateData { | ||
22 | + unsigned transitionsNum : 7; | ||
23 | + unsigned accepting : 1; | ||
24 | +}; | ||
25 | + | ||
26 | +struct TransitionData { | ||
27 | + char label; | ||
28 | + unsigned targetOffset : 24; | ||
29 | +}; | ||
30 | + | ||
31 | +#pragma pack(pop) /* restore original alignment from stack */ | ||
32 | + | ||
33 | +static bool compareTransitions(TransitionData t1, TransitionData t2) { | ||
34 | + return t1.label < t2.label; | ||
35 | +} | ||
36 | + | ||
37 | +template <class T> | ||
38 | +SimpleFSA<T>::SimpleFSA(const unsigned char* ptr, const Deserializer<T>& deserializer) | ||
39 | +: FSA<T>(ptr, deserializer) { | ||
40 | +} | ||
41 | + | ||
42 | +template <class T> | ||
43 | +SimpleFSA<T>::~SimpleFSA() { | ||
44 | + | ||
45 | +} | ||
46 | + | ||
47 | +static void debugState(const StateData* stateData) { | ||
48 | + cerr << "STATE" << endl; | ||
49 | + cerr << stateData->transitionsNum << " " << stateData->accepting << endl; | ||
50 | +} | ||
51 | + | ||
52 | +static void debugTransitions(const TransitionData* transitionsTable, const TransitionData* transitionsEnd) { | ||
53 | + int offset = 0; | ||
54 | + cerr << "TRANSITIONS" << endl; | ||
55 | + while (transitionsTable + offset < transitionsEnd) { | ||
56 | + const TransitionData td = *(transitionsTable + offset); | ||
57 | + if ((td.label <= 'z' && 'a' <= td.label)) | ||
58 | + cerr << td.label << " " << td.targetOffset << endl; | ||
59 | + else { | ||
60 | + cerr << ((int) td.label) << " " << td.targetOffset << endl; | ||
61 | + } | ||
62 | + offset++; | ||
63 | + } | ||
64 | +} | ||
65 | + | ||
66 | +template <class T> | ||
67 | +void SimpleFSA<T>::proceedToNext(const char c, State<T>& state) const { | ||
68 | + if (c<= 'z' && 'a' <= c) | ||
69 | + cerr << "NEXT " << c << " from " << state.getOffset() << endl; | ||
70 | + else | ||
71 | + cerr << "NEXT " << (short) c << " from " << state.getOffset() << endl; | ||
72 | + const unsigned char* fromPointer = this->startPtr + state.getOffset(); | ||
73 | + int transitionsTableOffset = sizeof (StateData); | ||
74 | + if (state.isAccepting()) { | ||
75 | + transitionsTableOffset += state.getValueSize(); | ||
76 | + cerr << "transitionsTableOffset " << transitionsTableOffset + state.getOffset() << " because value is " << state.getValue() << endl; | ||
77 | + } | ||
78 | + const StateData* stateData = reinterpret_cast<const StateData*> (fromPointer); | ||
79 | + const TransitionData* transitionsTable = reinterpret_cast<const TransitionData*> (fromPointer + transitionsTableOffset); | ||
80 | + const TransitionData* transitionsEnd = transitionsTable + stateData->transitionsNum; | ||
81 | + debugState(stateData); | ||
82 | + debugTransitions(transitionsTable, transitionsEnd); | ||
83 | + const TransitionData* foundTransition = std::lower_bound( | ||
84 | + transitionsTable, transitionsEnd, | ||
85 | + TransitionData{c, 0}, | ||
86 | + compareTransitions); | ||
87 | + if (foundTransition == transitionsEnd || foundTransition->label != c) { | ||
88 | + cerr << "SINK" << (foundTransition == transitionsEnd) << " " << foundTransition->label << " for " << c << endl; | ||
89 | + state.setNextAsSink(); | ||
90 | + } | ||
91 | + else { | ||
92 | +// cerr << "FOUND " << foundTransition->label << " " << foundTransition->targetOffset << endl; | ||
93 | + const unsigned char* nextStatePointer = this->startPtr + foundTransition->targetOffset; | ||
94 | + const StateData* nextStateData = reinterpret_cast<const StateData*> (nextStatePointer); | ||
95 | + if (nextStateData->accepting) { | ||
96 | + cerr << "ACCEPTING" << endl; | ||
97 | + T object; | ||
98 | + int size = this->deserializer.deserialize(nextStatePointer + sizeof (StateData), object); | ||
99 | + state.setNext(foundTransition->targetOffset, object, size); | ||
100 | + } | ||
101 | + else { | ||
102 | + state.setNext(foundTransition->targetOffset); | ||
103 | + } | ||
104 | + } | ||
105 | +} | ||
106 | + | ||
107 | +#endif /* _SIMPLE_FSA_IMPL_HPP */ |
fsa/_state_impl.hpp
0 → 100644
1 | +/* | ||
2 | + * File: _state_impl.hpp | ||
3 | + * Author: mlenart | ||
4 | + * | ||
5 | + * Created on 21 październik 2013, 15:20 | ||
6 | + */ | ||
7 | + | ||
8 | +#ifndef _STATE_IMPL_HPP | ||
9 | +#define _STATE_IMPL_HPP | ||
10 | + | ||
11 | +#include <typeinfo> | ||
12 | +#include "fsa.hpp" | ||
13 | + | ||
14 | +using namespace std; | ||
15 | + | ||
16 | +template <class T> | ||
17 | +State<T>::State(const FSA<T>& fsa) | ||
18 | +: fsa(fsa), offset(0), accepting(false), sink(false), value(), valueSize(0) { | ||
19 | +} | ||
20 | + | ||
21 | +template <class T> | ||
22 | +bool State<T>::isSink() const { | ||
23 | + return this->sink; | ||
24 | +} | ||
25 | + | ||
26 | +template <class T> | ||
27 | +bool State<T>::isAccepting() const { | ||
28 | + return this->accepting; | ||
29 | +} | ||
30 | + | ||
31 | +template <class T> | ||
32 | +void State<T>::proceedToNext(const char c) { | ||
33 | + if (this->isSink()) { | ||
34 | + return; | ||
35 | + } | ||
36 | + else { | ||
37 | + this->fsa.proceedToNext(c, *this); | ||
38 | + } | ||
39 | +} | ||
40 | + | ||
41 | +template <class T> | ||
42 | +unsigned int State<T>::getOffset() const { | ||
43 | + assert(!this->isSink()); | ||
44 | + return this->offset; | ||
45 | +} | ||
46 | + | ||
47 | +template <class T> | ||
48 | +T State<T>::getValue() const { | ||
49 | + assert(this->isAccepting()); | ||
50 | + return this->value; | ||
51 | +} | ||
52 | + | ||
53 | +template <class T> | ||
54 | +unsigned int State<T>::getValueSize() const { | ||
55 | + assert(this->isAccepting()); | ||
56 | + return this->valueSize; | ||
57 | +} | ||
58 | + | ||
59 | +template <class T> | ||
60 | +State<T>::~State() { | ||
61 | + | ||
62 | +} | ||
63 | + | ||
64 | +template <class T> | ||
65 | +void State<T>::setNext(const unsigned int offset) { | ||
66 | + assert(!this->isSink()); | ||
67 | + this->offset = offset; | ||
68 | + this->accepting = false; | ||
69 | +} | ||
70 | + | ||
71 | +template <class T> | ||
72 | +void State<T>::setNext(const unsigned int offset, const T& value, const unsigned int valueSize) { | ||
73 | + assert(!this->isSink()); | ||
74 | + this->offset = offset; | ||
75 | + this->accepting = true; | ||
76 | + this->value = value; | ||
77 | + this->valueSize = valueSize; | ||
78 | +} | ||
79 | + | ||
80 | +template <class T> | ||
81 | +void State<T>::setNextAsSink() { | ||
82 | + this->sink = true; | ||
83 | + this->accepting = false; | ||
84 | +} | ||
85 | + | ||
86 | +#endif /* _STATE_IMPL_HPP */ | ||
87 | + |
fsa/fsa.hpp
0 → 100644
1 | +/* | ||
2 | + * File: fsa.hh | ||
3 | + * Author: mlenart | ||
4 | + * | ||
5 | + * Created on October 17, 2013, 2:00 PM | ||
6 | + */ | ||
7 | + | ||
8 | +#ifndef FSA_HPP | ||
9 | +#define FSA_HPP | ||
10 | + | ||
11 | +//#include <iostream> | ||
12 | +#include <cstring> | ||
13 | +#include <typeinfo> | ||
14 | +#include <cassert> | ||
15 | + | ||
16 | +template <class T> class State; | ||
17 | +template <class T> class FSA; | ||
18 | +template <class T> class Deserializer; | ||
19 | + | ||
20 | +template <class T> | ||
21 | +class Deserializer { | ||
22 | +public: | ||
23 | + | ||
24 | + /** | ||
25 | + * Deserialize object from ptr. | ||
26 | + * Returns number of bytes read or -1 on error. | ||
27 | + */ | ||
28 | + virtual int deserialize(const unsigned char* ptr, T& object) const = 0; | ||
29 | +}; | ||
30 | + | ||
31 | +class StringDeserializer : public Deserializer<char*> { | ||
32 | +public: | ||
33 | + | ||
34 | + StringDeserializer() { | ||
35 | + } | ||
36 | + | ||
37 | + /** | ||
38 | + * Deserialize object from ptr. | ||
39 | + * Returns number of bytes read or -1 on error. | ||
40 | + */ | ||
41 | + int deserialize(const unsigned char* ptr, char*& text) const { | ||
42 | + text = const_cast<char*> (reinterpret_cast<const char*> (ptr)); | ||
43 | + return strlen(text) + 1; | ||
44 | + } | ||
45 | +}; | ||
46 | + | ||
47 | +/** | ||
48 | + * Finite state automaton. | ||
49 | + */ | ||
50 | +template <class T> | ||
51 | +class FSA { | ||
52 | +public: | ||
53 | + | ||
54 | + /** | ||
55 | + * Get this automaton's initial state. | ||
56 | + */ | ||
57 | + State<T> getInitialState() const { | ||
58 | + return State<T>(*this); | ||
59 | + } | ||
60 | + | ||
61 | + bool tryToRecognize(const char* input, T& value) const { | ||
62 | + State<T> currState = this->getInitialState(); | ||
63 | + int i = 0; | ||
64 | + while (!currState.isSink() && input[i] != '\0') { | ||
65 | + currState.proceedToNext(input[i]); | ||
66 | + i++; | ||
67 | + } | ||
68 | + if (currState.isAccepting()) { | ||
69 | + value = currState.getValue(); | ||
70 | + return true; | ||
71 | + } | ||
72 | + else { | ||
73 | + return false; | ||
74 | + } | ||
75 | + } | ||
76 | + | ||
77 | + virtual ~FSA() { | ||
78 | + } | ||
79 | +protected: | ||
80 | + | ||
81 | + FSA(const unsigned char* ptr, const Deserializer<T>& deserializer) | ||
82 | + : startPtr(ptr), deserializer(deserializer) { | ||
83 | + } | ||
84 | + /** | ||
85 | + * Proceed to next state | ||
86 | + * | ||
87 | + * @param fromPointer - wskaźnik | ||
88 | + * @param c - char for the transition. | ||
89 | + * @return next state | ||
90 | + */ | ||
91 | + virtual void proceedToNext(const char c, State<T>& state) const = 0; | ||
92 | + const unsigned char* startPtr; | ||
93 | + const Deserializer<T>& deserializer; | ||
94 | + friend class State<T>; | ||
95 | +private: | ||
96 | + // FSA(); | ||
97 | +}; | ||
98 | + | ||
99 | +template <class T> | ||
100 | +class SimpleFSA : public FSA<T> { | ||
101 | +public: | ||
102 | + SimpleFSA(const unsigned char* ptr, const Deserializer<T>& deserializer); | ||
103 | + virtual ~SimpleFSA(); | ||
104 | +protected: | ||
105 | + void proceedToNext(const char c, State<T>& state) const; | ||
106 | +private: | ||
107 | + | ||
108 | +}; | ||
109 | + | ||
110 | +#include "_simple_fsa_impl.hpp" | ||
111 | + | ||
112 | +/** | ||
113 | + * A state in an FSA. | ||
114 | + */ | ||
115 | +template <class T> | ||
116 | +class State { | ||
117 | +public: | ||
118 | + | ||
119 | + /** | ||
120 | + * Is this a "sink" state - non-accepting state without outgoing transitions | ||
121 | + */ | ||
122 | + bool isSink() const; | ||
123 | + | ||
124 | + /** | ||
125 | + * Is this an accepting state | ||
126 | + */ | ||
127 | + bool isAccepting() const; | ||
128 | + | ||
129 | + /** | ||
130 | + * Get next state proceeding a transition for given character. | ||
131 | + */ | ||
132 | + void proceedToNext(const char c); | ||
133 | + | ||
134 | + /** | ||
135 | + * Get value of this state. | ||
136 | + * Makes sense only for accepting states. | ||
137 | + * For non-accepting states is throws an exception. | ||
138 | + */ | ||
139 | + T getValue() const; | ||
140 | + | ||
141 | + /** | ||
142 | + * Get the size (in bytes) of this state's value. | ||
143 | + * Makes sense only for accepting states. | ||
144 | + * For non-accepting states is throws an exception. | ||
145 | + */ | ||
146 | + unsigned int getValueSize() const; | ||
147 | + | ||
148 | + unsigned int getOffset() const; | ||
149 | + | ||
150 | + void setNext(const unsigned int offset); | ||
151 | + void setNext(const unsigned int offset, const T& value, const unsigned int valueSize); | ||
152 | + void setNextAsSink(); | ||
153 | + | ||
154 | + State(const FSA<T>& fsa); | ||
155 | + | ||
156 | + virtual ~State(); | ||
157 | +private: | ||
158 | + const FSA<T>& fsa; | ||
159 | + unsigned int offset; | ||
160 | + bool accepting; | ||
161 | + bool sink; | ||
162 | + T value; | ||
163 | + int valueSize; | ||
164 | +}; | ||
165 | + | ||
166 | +#include "_state_impl.hpp" | ||
167 | + | ||
168 | +#endif /* FSA_HPP */ | ||
169 | + | ||
170 | + |
fsa/test_dict.cpp
0 → 100644
1 | +/* | ||
2 | + * File: test.cpp | ||
3 | + * Author: lennyn | ||
4 | + * | ||
5 | + * Created on October 22, 2013, 2:11 PM | ||
6 | + */ | ||
7 | + | ||
8 | +#include <cstdlib> | ||
9 | +#include <iostream> | ||
10 | +#include <fstream> | ||
11 | +#include <string> | ||
12 | +#include <sstream> | ||
13 | +#include <algorithm> | ||
14 | +#include <functional> | ||
15 | +#include <cctype> | ||
16 | +#include <locale> | ||
17 | +#include "fsa.hpp" | ||
18 | + | ||
19 | +using namespace std; | ||
20 | + | ||
21 | +void validate(const bool cond, const string& msg) { | ||
22 | + if (!cond) { | ||
23 | + cerr << msg << endl; | ||
24 | + exit(1); | ||
25 | + } | ||
26 | +} | ||
27 | + | ||
28 | +unsigned char* readFile(const char* fname) { | ||
29 | + ifstream ifs; | ||
30 | + ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit); | ||
31 | + ifs.open(fname, ios::in | ios::binary | ios::ate); | ||
32 | + // if (ifs.is_open()) { | ||
33 | + int size = ifs.tellg(); | ||
34 | + unsigned char* memblock = new unsigned char [size]; | ||
35 | + ifs.seekg(0, ios::beg); | ||
36 | + ifs.read(reinterpret_cast<char*> (memblock), size); | ||
37 | + ifs.close(); | ||
38 | + return memblock; | ||
39 | + // } | ||
40 | + // else { | ||
41 | + // cerr << "Unable to open file " << fname << endl; | ||
42 | + // } | ||
43 | +} | ||
44 | + | ||
45 | +std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) { | ||
46 | + std::stringstream ss(s); | ||
47 | + std::string item; | ||
48 | + while (std::getline(ss, item, delim)) { | ||
49 | + elems.push_back(item); | ||
50 | + } | ||
51 | + return elems; | ||
52 | +} | ||
53 | + | ||
54 | + | ||
55 | +std::vector<std::string> split(const std::string &s, char delim) { | ||
56 | + std::vector<std::string> elems; | ||
57 | + split(s, delim, elems); | ||
58 | + return elems; | ||
59 | +} | ||
60 | + | ||
61 | +static inline string &rtrim(string &s) { | ||
62 | + s.erase(find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(), s.end()); | ||
63 | + return s; | ||
64 | +} | ||
65 | + | ||
66 | +void testFSA(const FSA<char*>& fsa, const char* fname) { | ||
67 | + ifstream ifs; | ||
68 | +// ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit); | ||
69 | + ifs.open(fname, ios::binary); | ||
70 | + string line; | ||
71 | + while (getline(ifs, line)) { | ||
72 | + vector<string> split1(split(line, '\t')); | ||
73 | + string key = split1[0]; | ||
74 | + key = "bijekcją"; | ||
75 | + string value = split1[1]; | ||
76 | + | ||
77 | + for (unsigned int i = 0; i < key.length(); i++) { | ||
78 | + cout << (int) key[i] << " "; | ||
79 | + } | ||
80 | + cout << endl; | ||
81 | + | ||
82 | + char* value2; | ||
83 | + if (fsa.tryToRecognize(key.c_str(), value2)) { | ||
84 | + if (string(value) != string(value2)) { | ||
85 | + cout << "BAD INTERP " << key << " " << value << " != " << value2 << endl; | ||
86 | + } | ||
87 | + else { | ||
88 | + cout << "OK! " << key << " " << value << endl; | ||
89 | + } | ||
90 | + } | ||
91 | + else { | ||
92 | + cout << "MISS " << key << " " << value << " not recognized" << endl; | ||
93 | + } | ||
94 | + } | ||
95 | + cout << ifs.good() << endl; | ||
96 | + cout << ifs.fail() << endl; | ||
97 | + cout << ifs.eof() << endl; | ||
98 | + cout << "done" << endl; | ||
99 | +} | ||
100 | + | ||
101 | +/* | ||
102 | + * | ||
103 | + */ | ||
104 | +int main(int argc, char** argv) { | ||
105 | + validate(argc == 3, "Must provide exactly two arguments - FSA filename and dictionary filename."); | ||
106 | + const unsigned char* fsaData = readFile(argv[1]); | ||
107 | + StringDeserializer deserializer; | ||
108 | + SimpleFSA<char*> fsa(fsaData, deserializer); | ||
109 | + testFSA(fsa, argv[2]); | ||
110 | + cout << argc << endl; | ||
111 | + return 0; | ||
112 | +} | ||
113 | + |
fsabuilder/.settings/org.eclipse.core.resources.prefs
0 → 100644
fsabuilder/fsa/__init__.py
0 → 100644
fsabuilder/fsa/buildfsa.py
0 → 100644
1 | +# -*- coding:utf-8 -*- | ||
2 | +''' | ||
3 | +Created on 21 paź 2013 | ||
4 | + | ||
5 | +@author: mlenart | ||
6 | +''' | ||
7 | + | ||
8 | +import sys | ||
9 | +import logging | ||
10 | +import codecs | ||
11 | +import encode | ||
12 | +import convertinput | ||
13 | +from fsa import FSA | ||
14 | +from serializer import SimpleSerializerWithStringValues | ||
15 | +from visualizer import Visualizer | ||
16 | +from optparse import OptionParser | ||
17 | + | ||
18 | +logging.basicConfig(level=logging.DEBUG) | ||
19 | + | ||
20 | +class OutputFormat(): | ||
21 | + BINARY = 'BINARY' | ||
22 | + CPP = 'CPP' | ||
23 | + | ||
24 | +class InputFormat(): | ||
25 | + ENCODED = 'ENCODED' | ||
26 | + POLIMORF = 'POLIMORF' | ||
27 | + | ||
28 | +def parseOptions(): | ||
29 | + """ | ||
30 | + Parses commandline args | ||
31 | + """ | ||
32 | + parser = OptionParser() | ||
33 | + parser.add_option('-i', '--input-file', | ||
34 | + dest='inputFile', | ||
35 | + metavar='FILE', | ||
36 | + help='path to input file') | ||
37 | + parser.add_option('-o', '--output-file', | ||
38 | + dest='outputFile', | ||
39 | + metavar='FILE', | ||
40 | + help='path to output file') | ||
41 | + parser.add_option('--input-format', | ||
42 | + dest='inputFormat', | ||
43 | + help='input format - ENCODED or POLIMORF') | ||
44 | + parser.add_option('--output-format', | ||
45 | + dest='outputFormat', | ||
46 | + help='output format - BINARY or CPP') | ||
47 | + parser.add_option('--visualize', | ||
48 | + dest='visualize', | ||
49 | + action='store_true', | ||
50 | + default=False, | ||
51 | + help='visualize result') | ||
52 | + | ||
53 | + opts, args = parser.parse_args() | ||
54 | + | ||
55 | + if None in [opts.inputFile, opts.outputFile, opts.outputFormat, opts.inputFormat]: | ||
56 | + parser.print_help() | ||
57 | + exit(1) | ||
58 | + if not opts.outputFormat.upper() in [OutputFormat.BINARY, OutputFormat.CPP]: | ||
59 | + print >> sys.stderr, 'output format must be one of ('+str([OutputFormat.BINARY, OutputFormat.CPP])+')' | ||
60 | + exit(1) | ||
61 | + if not opts.inputFormat.upper() in [InputFormat.ENCODED, InputFormat.POLIMORF]: | ||
62 | + print >> sys.stderr, 'input format must be one of ('+str([InputFormat.ENCODED, InputFormat.POLIMORF])+')' | ||
63 | + exit(1) | ||
64 | + return opts | ||
65 | + | ||
66 | +def readEncodedInput(inputFile): | ||
67 | + with codecs.open(inputFile, 'r', 'utf8') as f: | ||
68 | + for line in f.readlines(): | ||
69 | + word, interps = line.strip().split() | ||
70 | + yield word, interps.split(u'|') | ||
71 | + | ||
72 | +def readPolimorfInput(inputFile, encoder): | ||
73 | + with codecs.open(inputFile, 'r', 'utf8') as f: | ||
74 | + for entry in convertinput.convertPolimorf(f.readlines(), lambda (word, interp): encoder.word2SortKey(word)): | ||
75 | + yield entry | ||
76 | + | ||
77 | +if __name__ == '__main__': | ||
78 | + opts = parseOptions() | ||
79 | + encoder = encode.Encoder() | ||
80 | + fsa = FSA(encoder) | ||
81 | + serializer = SimpleSerializerWithStringValues() | ||
82 | + | ||
83 | + inputData = readEncodedInput(opts.inputFile) \ | ||
84 | + if opts.inputFormat == InputFormat.ENCODED \ | ||
85 | + else readPolimorfInput(opts.inputFile, encoder) | ||
86 | + | ||
87 | + logging.info('feeding FSA with data ...') | ||
88 | + fsa.feed(inputData) | ||
89 | + logging.info('states num: '+str(fsa.getStatesNum())) | ||
90 | + if opts.outputFormat == 'CPP': | ||
91 | + serializer.serialize2CppFile(fsa, opts.outputFile) | ||
92 | + else: | ||
93 | + serializer.serialize2BinaryFile(fsa, opts.outputFile) | ||
94 | + if opts.visualize: | ||
95 | + Visualizer().visualize(fsa) |
fsabuilder/fsa/convertinput.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 23, 2013 | ||
3 | + | ||
4 | +@author: mlenart | ||
5 | +''' | ||
6 | +import sys | ||
7 | +import fileinput | ||
8 | +import logging | ||
9 | +from encode import Encoder | ||
10 | + | ||
11 | +def _encodeInterp(orth, base, tag, name): | ||
12 | + removePrefix = 0 | ||
13 | + root = u'' | ||
14 | + for o, b in zip(orth, base): | ||
15 | + if o == b: | ||
16 | + root += o | ||
17 | + else: | ||
18 | + break | ||
19 | + removeSuffixNum = len(orth) - len(root) | ||
20 | + addSuffix = base[len(root):] | ||
21 | + return u'+'.join([ | ||
22 | + chr(ord('A')+removePrefix) + chr(ord('A')+removeSuffixNum) + addSuffix, | ||
23 | + tag, | ||
24 | + name]) | ||
25 | + | ||
26 | +def _parsePolimorf(inputLines): | ||
27 | + for line0 in inputLines: | ||
28 | + line = line0.strip(u'\n') | ||
29 | + if line: | ||
30 | +# print line | ||
31 | + orth, base, tag, name = line.split(u'\t') | ||
32 | + yield (orth, _encodeInterp(orth, base, tag, name)) | ||
33 | + | ||
34 | +def _sortAndMergeParsedInput(inputData, key=lambda k: k): | ||
35 | + logging.info('sorting input...') | ||
36 | + entries = list(inputData) | ||
37 | + entries.sort(key=key) | ||
38 | + logging.info('done sorting') | ||
39 | + prevOrth = None | ||
40 | + prevInterps = None | ||
41 | + for orth, interp in entries: | ||
42 | + if prevOrth and prevOrth == orth: | ||
43 | + prevInterps.append(interp) | ||
44 | + else: | ||
45 | + if prevOrth: | ||
46 | + yield (prevOrth, sorted(set(prevInterps))) | ||
47 | + prevOrth = orth | ||
48 | + prevInterps = [interp] | ||
49 | + | ||
50 | +def convertPolimorf(inputLines, sortKey=lambda k: k): | ||
51 | + for orth, interps in _sortAndMergeParsedInput(_parsePolimorf(inputLines), key=sortKey): | ||
52 | + yield orth, interps | ||
53 | + | ||
54 | +def _decodeInputLines(rawInputLines, encoding): | ||
55 | + for line in rawInputLines: | ||
56 | + yield line.decode(encoding) | ||
57 | + | ||
58 | +if __name__ == '__main__': | ||
59 | + encoder = Encoder() | ||
60 | + for orth, interps in convertPolimorf(_decodeInputLines(fileinput.input(), 'utf8'), lambda (orth, interp): encoder.word2SortKey(orth)): | ||
61 | + print u'\t'.join([orth, u'|'.join(interps)]).encode('utf8') |
fsabuilder/fsa/encode.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 23, 2013 | ||
3 | + | ||
4 | +@author: lennyn | ||
5 | +''' | ||
6 | + | ||
7 | +class Encoder(object): | ||
8 | + ''' | ||
9 | + classdocs | ||
10 | + ''' | ||
11 | + | ||
12 | + | ||
13 | + def __init__(self, encoding='utf8'): | ||
14 | + ''' | ||
15 | + Constructor | ||
16 | + ''' | ||
17 | + self.encoding = encoding | ||
18 | + | ||
19 | + def encodeWord(self, word): | ||
20 | + return bytearray(word, self.encoding) | ||
21 | + | ||
22 | + def encodeData(self, data): | ||
23 | + return bytearray(u'|'.join(data).encode(self.encoding)) + bytearray([0]) | ||
24 | + | ||
25 | + def decodeData(self, rawData): | ||
26 | +# print unicode(str(rawData), self.encoding)[:-1] | ||
27 | +# print unicode(str(rawData), self.encoding)[:-1].split(u'|') | ||
28 | + return unicode(str(rawData), self.encoding)[:-1].split(u'|') | ||
29 | + | ||
30 | + def word2SortKey(self, word): | ||
31 | + return word.encode(self.encoding) |
fsabuilder/fsa/fsa.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 8, 2013 | ||
3 | + | ||
4 | +@author: mlenart | ||
5 | +''' | ||
6 | + | ||
7 | +import state | ||
8 | +import register | ||
9 | +import logging | ||
10 | + | ||
11 | +class FSA(object): | ||
12 | + ''' | ||
13 | + A finite state automaton | ||
14 | + ''' | ||
15 | + | ||
16 | + | ||
17 | + def __init__(self, encoder): | ||
18 | + self.encodeWord = encoder.encodeWord | ||
19 | + self.encodeData = encoder.encodeData | ||
20 | + self.decodeData = encoder.decodeData | ||
21 | + self.encodedPrevWord = None | ||
22 | + self.initialState = state.State() | ||
23 | + self.register = register.Register() | ||
24 | + | ||
25 | + def tryToRecognize(self, word): | ||
26 | + return self.decodeData(self.initialState.tryToRecognize(self.encodeWord(word))) | ||
27 | + | ||
28 | + def feed(self, input): | ||
29 | + | ||
30 | + for n, (word, data) in enumerate(input, start=1): | ||
31 | + assert data is not None | ||
32 | + if type(data) in [str, unicode]: | ||
33 | + data = [data] | ||
34 | + encodedWord = self.encodeWord(word) | ||
35 | + assert encodedWord > self.encodedPrevWord | ||
36 | + self._addSorted(encodedWord, self.encodeData(data)) | ||
37 | + self.encodedPrevWord = encodedWord | ||
38 | + assert self.tryToRecognize(word) == data | ||
39 | + if n % 10000 == 0: | ||
40 | + logging.info(word) | ||
41 | + | ||
42 | + self.initialState = self._replaceOrRegister(self.initialState, self.encodeWord(word)) | ||
43 | + self.encodedPrevWord = None | ||
44 | + | ||
45 | + def getStatesNum(self): | ||
46 | + return self.register.getStatesNum() | ||
47 | + | ||
48 | + def _addSorted(self, encodedWord, data): | ||
49 | + assert self.encodedPrevWord < encodedWord | ||
50 | + q = self.initialState | ||
51 | + i = 0 | ||
52 | + while i <= len(encodedWord) and q.hasNext(encodedWord[i]): | ||
53 | + q = q.getNext(encodedWord[i]) | ||
54 | + i += 1 | ||
55 | + if self.encodedPrevWord and i < len(self.encodedPrevWord): | ||
56 | + nextState = q.getNext(self.encodedPrevWord[i]) | ||
57 | + q.setTransition( | ||
58 | + self.encodedPrevWord[i], | ||
59 | + self._replaceOrRegister(nextState, self.encodedPrevWord[i+1:])) | ||
60 | + | ||
61 | + while i < len(encodedWord): | ||
62 | + q.setTransition(encodedWord[i], state.State()) | ||
63 | + q = q.getNext(encodedWord[i]) | ||
64 | + i += 1 | ||
65 | + | ||
66 | + assert q.encodedData is None | ||
67 | +# print q, encodedData | ||
68 | + q.encodedData = data | ||
69 | + | ||
70 | + def _replaceOrRegister(self, q, encodedWord): | ||
71 | + if encodedWord: | ||
72 | + nextState = q.getNext(encodedWord[0]) | ||
73 | + q.setTransition( | ||
74 | + encodedWord[0], | ||
75 | + self._replaceOrRegister(nextState, encodedWord[1:])) | ||
76 | + | ||
77 | + if self.register.containsEquivalentState(q): | ||
78 | + return self.register.getEquivalentState(q) | ||
79 | + else: | ||
80 | + self.register.addState(q) | ||
81 | + return q | ||
82 | + | ||
83 | + def calculateOffsets(self, sizeCounter): | ||
84 | + currReverseOffset = 0 | ||
85 | + for state in self.initialState.dfs(set()): | ||
86 | + currReverseOffset += sizeCounter(state) | ||
87 | + state.reverseOffset = currReverseOffset | ||
88 | + for state in self.initialState.dfs(set()): | ||
89 | + state.offset = currReverseOffset - state.reverseOffset | ||
90 | + | ||
91 | + | ||
92 | + | ||
0 | \ No newline at end of file | 93 | \ No newline at end of file |
fsabuilder/fsa/register.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 8, 2013 | ||
3 | + | ||
4 | +@author: mlenart | ||
5 | +''' | ||
6 | + | ||
7 | +class Register(object): | ||
8 | + ''' | ||
9 | + States register. | ||
10 | + ''' | ||
11 | + | ||
12 | + | ||
13 | + def __init__(self): | ||
14 | + self._map = {} | ||
15 | + | ||
16 | + def addState(self, state): | ||
17 | + self._map[state.getRegisterKey()] = state | ||
18 | + | ||
19 | + def getEquivalentState(self, state): | ||
20 | + return self._map[state.getRegisterKey()] | ||
21 | + | ||
22 | + def containsEquivalentState(self, state): | ||
23 | + return state.getRegisterKey() in self._map | ||
24 | + | ||
25 | + def getStatesNum(self): | ||
26 | + return len(self._map) |
fsabuilder/fsa/serializer.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 20, 2013 | ||
3 | + | ||
4 | +@author: mlenart | ||
5 | +''' | ||
6 | + | ||
7 | +class Serializer(object): | ||
8 | + | ||
9 | + def __init__(self): | ||
10 | + pass | ||
11 | + | ||
12 | + def serialize2CppFile(self, fsa, fname): | ||
13 | + res = [] | ||
14 | + fsa.calculateOffsets(sizeCounter=lambda state: self.getStateSize(state)) | ||
15 | + res.append('const unsigned char DEFAULT_FSA[] = {') | ||
16 | + for idx, state in enumerate(sorted(fsa.initialState.dfs(set()), key=lambda state: state.offset)): | ||
17 | + res.append('// state '+str(idx)) | ||
18 | + partRes = [] | ||
19 | + for byte in self.state2bytearray(state): | ||
20 | + partRes.append(hex(byte)) | ||
21 | + partRes.append(',') | ||
22 | + res.append(' '.join(partRes)) | ||
23 | + res.append('}') | ||
24 | + with open(fname, 'w') as f: | ||
25 | + f.write('\n'.join(res)) | ||
26 | + | ||
27 | + def serialize2BinaryFile(self, fsa, fname): | ||
28 | + res = bytearray() | ||
29 | + fsa.calculateOffsets(sizeCounter=lambda state: self.getStateSize(state)) | ||
30 | + for state in sorted(fsa.initialState.dfs(set()), key=lambda state: state.offset): | ||
31 | +# res.append('// state '+str(idx)) | ||
32 | + res.extend(self.state2bytearray(state)) | ||
33 | + with open(fname, 'wb') as f: | ||
34 | + f.write(res) | ||
35 | + | ||
36 | + def getStateSize(self, state): | ||
37 | + raise NotImplementedError('Not implemented') | ||
38 | + | ||
39 | + def fsa2bytearray(self, fsa): | ||
40 | + res = bytearray() | ||
41 | + fsa.calculateOffsets(sizeCounter=lambda state: self.getStateSize(state)) | ||
42 | + for state in sorted(fsa.initialState.dfs(set()), key=state.offset): | ||
43 | + res.extend(self.state2bytearray(state)) | ||
44 | + return res | ||
45 | + | ||
46 | + def state2bytearray(self, state): | ||
47 | + raise NotImplementedError('Not implemented') | ||
48 | + | ||
49 | +class SimpleSerializer(Serializer): | ||
50 | + | ||
51 | + ACCEPTING_FLAG = 128 | ||
52 | + | ||
53 | + def getStateSize(self, state): | ||
54 | + return 1 + 4 * len(state.transitionsMap.keys()) + self.getDataSize(state) | ||
55 | + | ||
56 | + def getDataSize(self, state): | ||
57 | + raise NotImplementedError('Not implemented') | ||
58 | + | ||
59 | + def state2bytearray(self, state): | ||
60 | + res = bytearray() | ||
61 | + res.extend(self._stateData2bytearray(state)) | ||
62 | + res.extend(self._transitionsData2bytearray(state)) | ||
63 | + return res | ||
64 | + | ||
65 | + def _stateData2bytearray(self, state): | ||
66 | + res = bytearray() | ||
67 | + firstByte = 0 | ||
68 | + if state.isAccepting(): | ||
69 | + firstByte |= SimpleSerializer.ACCEPTING_FLAG | ||
70 | + firstByte |= len(state.transitionsMap) | ||
71 | + assert firstByte < 256 and firstByte > 0 | ||
72 | + res.append(firstByte) | ||
73 | + if state.isAccepting(): | ||
74 | + res.extend(state.encodedData) | ||
75 | + return res | ||
76 | + | ||
77 | + def _transitionsData2bytearray(self, state): | ||
78 | + res = bytearray() | ||
79 | + # must sort that strange way because it must be sorted according to char, not unsigned char | ||
80 | + for byte, nextState in sorted(state.transitionsMap.iteritems(), key=lambda (c, _): c if (c >= 0 and c < 128) else c - 256): | ||
81 | + res.append(byte) | ||
82 | + offset = nextState.offset | ||
83 | + res.append(offset & 0x0000FF) | ||
84 | + res.append((offset & 0x00FF00) >> 8) | ||
85 | + res.append((offset & 0xFF0000) >> 16) | ||
86 | + return res | ||
87 | + | ||
88 | +class SimpleSerializerWithStringValues(SimpleSerializer): | ||
89 | + | ||
90 | + def getDataSize(self, state): | ||
91 | + assert type(state.encodedData) == bytearray or not state.isAccepting() | ||
92 | + return len(state.encodedData) if state.isAccepting() else 0 | ||
93 | + | ||
0 | \ No newline at end of file | 94 | \ No newline at end of file |
fsabuilder/fsa/state.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 8, 2013 | ||
3 | + | ||
4 | +@author: mlenart | ||
5 | +''' | ||
6 | + | ||
7 | +class State(object): | ||
8 | + ''' | ||
9 | + A state in an automaton | ||
10 | + ''' | ||
11 | + | ||
12 | + def __init__(self): | ||
13 | + self.transitionsMap = {} | ||
14 | + self.encodedData = None | ||
15 | + self.reverseOffset = None | ||
16 | + self.offset = None | ||
17 | + | ||
18 | + def setTransition(self, byte, nextState): | ||
19 | + self.transitionsMap[byte] = nextState | ||
20 | + | ||
21 | + def hasNext(self, byte): | ||
22 | + return byte in self.transitionsMap | ||
23 | + | ||
24 | + def getNext(self, byte): | ||
25 | + return self.transitionsMap.get(byte, None) | ||
26 | + | ||
27 | + def getRegisterKey(self): | ||
28 | + return ( frozenset(self.transitionsMap.iteritems()), tuple(self.encodedData) if self.encodedData else None ) | ||
29 | + | ||
30 | + def isAccepting(self): | ||
31 | + return self.encodedData is not None | ||
32 | + | ||
33 | + def tryToRecognize(self, word): | ||
34 | + if word: | ||
35 | + nextState = self.getNext(word[0]) | ||
36 | + if nextState: | ||
37 | + return nextState.tryToRecognize(word[1:]) | ||
38 | + else: | ||
39 | + return False | ||
40 | + else: | ||
41 | + return self.encodedData | ||
42 | + | ||
43 | + def dfs(self, alreadyVisited): | ||
44 | + if not self in alreadyVisited: | ||
45 | + for _, state in sorted(self.transitionsMap.iteritems()): | ||
46 | + for state1 in state.dfs(alreadyVisited): | ||
47 | + yield state1 | ||
48 | + alreadyVisited.add(self) | ||
49 | + yield self |
fsabuilder/fsa/test/__init__.py
0 → 100644
fsabuilder/fsa/test/testConstruction.py
0 → 100644
1 | +#-*- coding: utf-8 -*- | ||
2 | +''' | ||
3 | +Created on Oct 8, 2013 | ||
4 | + | ||
5 | +@author: lennyn | ||
6 | +''' | ||
7 | +import unittest | ||
8 | +from fsa import fsa, visualizer, encode | ||
9 | + | ||
10 | +class Test(unittest.TestCase): | ||
11 | + | ||
12 | + | ||
13 | + def testSimpleConstruction(self): | ||
14 | + print 'dupa' | ||
15 | + a = fsa.FSA(encode.Encoder()) | ||
16 | + input = sorted([ | ||
17 | + (u'bić', ''), | ||
18 | + (u'bij', ''), | ||
19 | + (u'biją', ''), | ||
20 | + (u'bijcie', ''), | ||
21 | + (u'bije', ''), | ||
22 | + (u'bijecie', ''), | ||
23 | + (u'bijemy', ''), | ||
24 | + (u'bijesz', ''), | ||
25 | + (u'biję', ''), | ||
26 | + (u'bijmy', ''), | ||
27 | + (u'bili', 'asd'), | ||
28 | + (u'biliby', ''), | ||
29 | + (u'bilibyście', ''), | ||
30 | + (u'bilibyśmy', ''), | ||
31 | + (u'biliście', 'asdfas'), | ||
32 | + (u'biliśmy', ''), | ||
33 | + (u'bił', 'wersadfas'), | ||
34 | + (u'biła', 'asdfasd'), | ||
35 | + (u'biłaby', 'asdfa'), | ||
36 | + (u'biłabym', ''), | ||
37 | + (u'biłabyś', 'asdfa'), | ||
38 | + (u'biłam', 'dfas'), | ||
39 | + (u'biłaś', 'asdfas'), | ||
40 | + (u'biłby', ''), | ||
41 | + (u'biłbym', 'asdfa'), | ||
42 | + (u'biłbyś', ''), | ||
43 | + (u'biłem', ''), | ||
44 | + (u'biłeś', 'sadfa'), | ||
45 | + (u'biły', ''), | ||
46 | + (u'biłyby', ''), | ||
47 | + (u'biłybyście', ''), | ||
48 | + (u'biłybyśmy', ''), | ||
49 | + (u'biłyście', ''), | ||
50 | + (u'biłyśmy', ''), | ||
51 | + ], key=lambda w: bytearray(w[0], 'utf8')) | ||
52 | + a.feed(input) | ||
53 | + print a.getStatesNum() | ||
54 | +# print a.tryToRecognize(u'bi') | ||
55 | +# print a.tryToRecognize(u'bić') | ||
56 | +# print a.tryToRecognize(u'bili') | ||
57 | + for w, res in input: | ||
58 | + print w, res, a.tryToRecognize(w) | ||
59 | + recognized = a.tryToRecognize(w) | ||
60 | + if type(res) in [str, unicode]: | ||
61 | + recognized = recognized[0] | ||
62 | + assert recognized == res | ||
63 | + a.calculateOffsets(lambda state: 1 + 4 * len(state.transitionsMap.keys()) + (len(state.encodedData) if state.isAccepting() else 0)) | ||
64 | + visualizer.Visualizer().visualize(a) | ||
65 | + print 'done' | ||
66 | + | ||
67 | +if __name__ == "__main__": | ||
68 | + #import sys;sys.argv = ['', 'Test.testSimpleConstruction'] | ||
69 | + unittest.main() | ||
0 | \ No newline at end of file | 70 | \ No newline at end of file |
fsabuilder/fsa/visualizer.py
0 → 100644
1 | +''' | ||
2 | +Created on Oct 20, 2013 | ||
3 | + | ||
4 | +@author: mlenart | ||
5 | +''' | ||
6 | + | ||
7 | +import networkx as nx | ||
8 | +import matplotlib.pyplot as plt | ||
9 | + | ||
10 | +class Visualizer(object): | ||
11 | + | ||
12 | + def __init__(self): | ||
13 | + pass | ||
14 | + | ||
15 | + def visualize(self, fsa): | ||
16 | + G = nx.DiGraph() | ||
17 | + allStates = list(reversed(list(fsa.initialState.dfs(set())))) | ||
18 | + edgeLabelsMap = {} | ||
19 | + nodeLabelsMap = {} | ||
20 | + for idx, state in enumerate(allStates): | ||
21 | + G.add_node(idx, offset=state.offset) | ||
22 | + for c, targetState in state.transitionsMap.iteritems(): | ||
23 | + G.add_edge(idx, allStates.index(targetState)) | ||
24 | + label = chr(c) if c <= 127 else '%' | ||
25 | + edgeLabelsMap[(idx, allStates.index(targetState))] = label | ||
26 | + nodeLabelsMap[idx] = state.offset if not state.isAccepting() else state.encodedData + '(' + str(state.offset) + ')' | ||
27 | + pos=nx.shell_layout(G) | ||
28 | + nx.draw_networkx_nodes(G, | ||
29 | + pos, | ||
30 | + nodelist=list([allStates.index(s) for s in allStates if not s.isAccepting()]), | ||
31 | + node_shape='s', | ||
32 | + node_color='w') | ||
33 | + nx.draw_networkx_nodes(G, | ||
34 | + pos, | ||
35 | + nodelist=list([allStates.index(s) for s in allStates if s.isAccepting()]), | ||
36 | + node_shape='s') | ||
37 | +# nx.draw_networkx_nodes(G, pos, nodelist=list([allStates.index(s) for s in allStates if s.isFinal()])), ) | ||
38 | + nx.draw_networkx_edges(G, pos, edgelist=edgeLabelsMap.keys()) | ||
39 | + nx.draw_networkx_edge_labels(G, pos, edge_labels = edgeLabelsMap) | ||
40 | + nx.draw_networkx_labels(G, pos, labels=nodeLabelsMap) | ||
41 | + plt.axis('off') | ||
42 | + plt.draw() | ||
43 | + plt.show() | ||
44 | +# plt.savefig('dupa.png') | ||
45 | + print 'done' | ||
0 | \ No newline at end of file | 46 | \ No newline at end of file |
fsabuilder/input/__init__.py
0 → 100644
morfeusz/CMakeLists.txt
0 → 100644
1 | +# Make sure the compiler can find include files from our Hello library. | ||
2 | +#include_directories (${Morfeusz_SOURCE_DIR}/FSALibrary) | ||
3 | + | ||
4 | +# Make sure the linker can find the Hello library once it is built. | ||
5 | +#link_directories (${Morfeusz_BINARY_DIR}/Hello) | ||
6 | +include_directories (${Morfeusz_SOURCE_DIR}/fsa) | ||
7 | +add_library (morfeusz2 morfeusz.hpp morfeusz.cpp) | ||
8 | +add_executable (morfeusz2_analyze main.cpp) | ||
9 | + | ||
10 | +# Link the executable to the Hello library. | ||
11 | +target_link_libraries (morfeusz2_analyze morfeusz2) | ||
12 | +set_target_properties ( morfeusz2_analyze PROPERTIES COMPILE_FLAGS "-std=gnu++0x" ) |
morfeusz/default_fsa.hpp
0 → 100644
morfeusz/main.cpp
0 → 100644
1 | +/* | ||
2 | + * File: main.cc | ||
3 | + * Author: mlenart | ||
4 | + * | ||
5 | + * Created on October 8, 2013, 12:41 PM | ||
6 | + */ | ||
7 | + | ||
8 | +#include <cstdlib> | ||
9 | +#include <iostream> | ||
10 | +#include "fsa.hpp" | ||
11 | +#include "default_fsa.hpp" | ||
12 | + | ||
13 | +using namespace std; | ||
14 | + | ||
15 | +/* | ||
16 | + * | ||
17 | + */ | ||
18 | +int main(int argc, char** argv) { | ||
19 | + unsigned char dupa[3] = {0376 | 1, 0111, 0234, }; | ||
20 | + char x = 255; | ||
21 | + cout << *reinterpret_cast<int*>(&x) << endl; | ||
22 | + return 0; | ||
23 | +} | ||
24 | + | ||
25 | + |
morfeusz/morfeusz.cpp
0 → 100644
morfeusz/morfeusz.hpp
0 → 100644
nbproject/configurations.xml
0 → 100644
1 | +<?xml version="1.0" encoding="UTF-8"?> | ||
2 | +<configurationDescriptor version="90"> | ||
3 | + <logicalFolder name="root" displayName="root" projectFiles="true" kind="ROOT"> | ||
4 | + <df root="fsa" name="0"> | ||
5 | + <in>_state_impl.hpp</in> | ||
6 | + </df> | ||
7 | + <df root="morfeusz" name="1"> | ||
8 | + <in>default_fsa.hpp</in> | ||
9 | + <in>main.cpp</in> | ||
10 | + <in>morfeusz.cpp</in> | ||
11 | + </df> | ||
12 | + <logicalFolder name="ExternalFiles" | ||
13 | + displayName="Important Files" | ||
14 | + projectFiles="false" | ||
15 | + kind="IMPORTANT_FILES_FOLDER"> | ||
16 | + <itemPath>CMakeLists.txt</itemPath> | ||
17 | + <itemPath>build/Makefile</itemPath> | ||
18 | + </logicalFolder> | ||
19 | + </logicalFolder> | ||
20 | + <sourceFolderFilter>^(nbproject)$</sourceFolderFilter> | ||
21 | + <sourceRootList> | ||
22 | + <Elem>fsa</Elem> | ||
23 | + <Elem>morfeusz</Elem> | ||
24 | + </sourceRootList> | ||
25 | + <projectmakefile>build/Makefile</projectmakefile> | ||
26 | + <confs> | ||
27 | + <conf name="Default" type="0"> | ||
28 | + <toolsSet> | ||
29 | + <compilerSet>default</compilerSet> | ||
30 | + <dependencyChecking>false</dependencyChecking> | ||
31 | + <rebuildPropChanged>false</rebuildPropChanged> | ||
32 | + </toolsSet> | ||
33 | + <codeAssistance> | ||
34 | + </codeAssistance> | ||
35 | + <makefileType> | ||
36 | + <makeTool> | ||
37 | + <buildCommandWorkingDir>build</buildCommandWorkingDir> | ||
38 | + <buildCommand>${MAKE} -f Makefile</buildCommand> | ||
39 | + <cleanCommand>${MAKE} -f Makefile clean</cleanCommand> | ||
40 | + <executablePath></executablePath> | ||
41 | + <ccTool> | ||
42 | + <incDir> | ||
43 | + <pElem>fsa</pElem> | ||
44 | + <pElem>build/morfeusz</pElem> | ||
45 | + </incDir> | ||
46 | + </ccTool> | ||
47 | + </makeTool> | ||
48 | + </makefileType> | ||
49 | + <item path="fsa/_state_impl.hpp" ex="false" tool="3" flavor2="0"> | ||
50 | + </item> | ||
51 | + <item path="morfeusz/default_fsa.hpp" ex="false" tool="3" flavor2="0"> | ||
52 | + </item> | ||
53 | + <item path="morfeusz/main.cpp" ex="false" tool="1" flavor2="8"> | ||
54 | + <ccTool> | ||
55 | + </ccTool> | ||
56 | + </item> | ||
57 | + <item path="morfeusz/morfeusz.cpp" ex="false" tool="1" flavor2="0"> | ||
58 | + </item> | ||
59 | + </conf> | ||
60 | + </confs> | ||
61 | +</configurationDescriptor> |
nbproject/project.xml
0 → 100644
1 | +<?xml version="1.0" encoding="UTF-8"?> | ||
2 | +<project xmlns="http://www.netbeans.org/ns/project/1"> | ||
3 | + <type>org.netbeans.modules.cnd.makeproject</type> | ||
4 | + <configuration> | ||
5 | + <data xmlns="http://www.netbeans.org/ns/make-project/1"> | ||
6 | + <name>morfeusz</name> | ||
7 | + <c-extensions/> | ||
8 | + <cpp-extensions>cpp</cpp-extensions> | ||
9 | + <header-extensions>hpp</header-extensions> | ||
10 | + <sourceEncoding>UTF-8</sourceEncoding> | ||
11 | + <make-dep-projects/> | ||
12 | + <sourceRootList> | ||
13 | + <sourceRootElem>fsa</sourceRootElem> | ||
14 | + <sourceRootElem>morfeusz</sourceRootElem> | ||
15 | + </sourceRootList> | ||
16 | + <confList> | ||
17 | + <confElem> | ||
18 | + <name>Default</name> | ||
19 | + <type>0</type> | ||
20 | + </confElem> | ||
21 | + </confList> | ||
22 | + <formatting> | ||
23 | + <project-formatting-style>false</project-formatting-style> | ||
24 | + </formatting> | ||
25 | + </data> | ||
26 | + </configuration> | ||
27 | +</project> |