TRIE構築系のC++ソース・コマンドを削除
@@ -1,146 +0,0 @@ | ||
1 | -#include <iostream> | |
2 | -#include <fstream> | |
3 | -#include <string> | |
4 | -#include <algorithm> | |
5 | -#include <cstdlib> | |
6 | -#include "trie/builder.hh" | |
7 | - | |
8 | -/** | |
9 | - * macro and function declaration | |
10 | - */ | |
11 | -#define CAN_DEC_FILE (data_dir+"/canonical-decomposition.def").c_str() | |
12 | -#define COM_DEC_FILE (data_dir+"/compatibility-decomposition.def").c_str() | |
13 | -#define CAN_COM_FILE (data_dir+"/canonical-composition.def").c_str() | |
14 | -#define CCC_FILE (data_dir+"/canonical-combining-class.def").c_str() | |
15 | -#define NFC_ILLEGAL_FILE (data_dir+"/nfc-illegal-char.def").c_str() | |
16 | -#define NFKC_ILLEGAL_FILE (data_dir+"/nfkc-illegal-char.def").c_str() | |
17 | - | |
18 | -bool read_mapping_definition(const char* filepath, const char* prefix, std::ofstream& out, std::string& buffer); | |
19 | -bool read_char_attr_definition(const char* filepath, const char* prefix, std::ofstream& out); | |
20 | - | |
21 | -/** | |
22 | - * main function | |
23 | - */ | |
24 | -int main(int argc, char** argv) { | |
25 | - if(argc != 3) { | |
26 | - std::cerr << "Usage: gen-unf-table <table-file(C++ header)> <data-dir>" << std::endl; | |
27 | - return 1; | |
28 | - } | |
29 | - | |
30 | - const char* table_file = argv[1]; | |
31 | - const std::string data_dir = argv[2]; | |
32 | - | |
33 | - std::cerr << "= create table file (C++ header file): " << table_file << std::endl; | |
34 | - std::ofstream out(table_file); | |
35 | - if(!out) { | |
36 | - std::cerr << "Can't open file for writing: " << table_file << std::endl; | |
37 | - return 1; | |
38 | - } | |
39 | - | |
40 | - // generate C++ header file | |
41 | - out << "#ifndef UNF_TABLE_HH" << std::endl | |
42 | - << "#define UNF_TABLE_HH" << std::endl | |
43 | - << "namespace UNF {" << std::endl | |
44 | - << " namespace TABLE {" << std::endl; | |
45 | - | |
46 | - // read definitions and write Node array | |
47 | - std::string buffer; | |
48 | - std::cerr << " == canonical decomposition mapping" << std::endl; | |
49 | - if(read_mapping_definition(CAN_DEC_FILE, "CANONICAL_DECOM", out, buffer)==false) | |
50 | - return 1; | |
51 | - | |
52 | - std::cerr << " == compatibility decomposition mapping" << std::endl; | |
53 | - if(read_mapping_definition(COM_DEC_FILE, "COMPATIBILITY_DECOM", out, buffer)==false) | |
54 | - return 1; | |
55 | - | |
56 | - std::cerr << " == canonical composition mapping" << std::endl; | |
57 | - if(read_mapping_definition(CAN_COM_FILE, "CANONICAL_COM", out, buffer)==false) | |
58 | - return 1; | |
59 | - | |
60 | - std::cerr << " == canonical combining class" << std::endl; | |
61 | - if(read_char_attr_definition(CCC_FILE, "CANONICAL_CLASS", out)==false) | |
62 | - return 1; | |
63 | - | |
64 | - std::cerr << " == NFC illegal character list" << std::endl; | |
65 | - if(read_char_attr_definition(NFC_ILLEGAL_FILE, "NFC_ILLEGAL", out)==false) | |
66 | - return 1; | |
67 | - | |
68 | - std::cerr << " == NFKC illegal character list" << std::endl; | |
69 | - if(read_char_attr_definition(NFKC_ILLEGAL_FILE, "NFKC_ILLEGAL", out)==false) | |
70 | - return 1; | |
71 | - | |
72 | - // write value string | |
73 | - out << "const char VALUE[]={" << std::endl; | |
74 | - for(unsigned i=0; i < buffer.size(); i++) { | |
75 | - out << std::setw(4) << std::setfill(' ') | |
76 | - << std::right << std::dec << static_cast<int>(buffer[i]); | |
77 | - | |
78 | - if(i+1 < buffer.size()) out << ','; | |
79 | - if((i+1)%20==0) out << std::endl; | |
80 | - } | |
81 | - out << "};" << std::endl; | |
82 | - | |
83 | - out << " }" << std::endl | |
84 | - << "}" << std::endl | |
85 | - << "#endif" << std::endl; | |
86 | - | |
87 | - std::cerr << "DONE" << std::endl; | |
88 | - return 0; | |
89 | -} | |
90 | - | |
91 | -/** | |
92 | - * function definition | |
93 | - */ | |
94 | -// File format: | |
95 | -// [FROM STRING]\t[TO STRING]\n | |
96 | -bool read_mapping_definition(const char* filepath, const char* prefix, std::ofstream& out, std::string& buffer) { | |
97 | - using UNF::Trie::MappingKey; | |
98 | - using UNF::Trie::MappingKeyList; | |
99 | - | |
100 | - std::ifstream in(filepath); | |
101 | - if(!in) { | |
102 | - std::cerr << "Can't open file: " << filepath << std::endl; | |
103 | - return false; | |
104 | - } | |
105 | - | |
106 | - MappingKeyList keys; | |
107 | - for(std::string line; std::getline(in,line);) { | |
108 | - std::size_t p = line.find('\t'); | |
109 | - std::string key = line.substr(0,p); | |
110 | - std::string value = line.substr(p+1); | |
111 | - | |
112 | - // search sharable value | |
113 | - // - using liner search (for simplicity) | |
114 | - // - very slow | |
115 | - std::size_t pos = buffer.find(value); | |
116 | - if(pos == std::string::npos) | |
117 | - keys.push_back(MappingKey(key, value, buffer)); | |
118 | - else | |
119 | - keys.push_back(MappingKey(key, value, pos)); | |
120 | - } | |
121 | - std::sort(keys.begin(), keys.end()); | |
122 | - | |
123 | - UNF::Trie::Builder<MappingKeyList>(keys).build().output_nodes_cpp_array(out, prefix); | |
124 | - return true; | |
125 | -} | |
126 | - | |
127 | -// File format: | |
128 | -// [two-digit hexadecimal] [CHARACTER] | |
129 | -bool read_char_attr_definition(const char* filepath, const char* prefix, std::ofstream& out) { | |
130 | - using UNF::Trie::AttrKey; | |
131 | - using UNF::Trie::AttrKeyList; | |
132 | - | |
133 | - std::ifstream in(filepath); | |
134 | - if(!in) { | |
135 | - std::cerr << "Can't open file: " << filepath << std::endl; | |
136 | - return false; | |
137 | - } | |
138 | - | |
139 | - AttrKeyList keys; | |
140 | - for(std::string line; std::getline(in,line);) | |
141 | - keys.push_back(AttrKey(line.substr(3), strtol(line.substr(0,2).c_str(),NULL,16))); | |
142 | - std::sort(keys.begin(), keys.end()); | |
143 | - | |
144 | - UNF::Trie::Builder<AttrKeyList>(keys).build().output_nodes_cpp_array(out, prefix); | |
145 | - return true; | |
146 | -} |
@@ -1,105 +0,0 @@ | ||
1 | -#ifndef UNF_TRIE_NODE_ALLOCATOR_HH | |
2 | -#define UNF_TRIE_NODE_ALLOCATOR_HH | |
3 | - | |
4 | -#include <vector> | |
5 | - | |
6 | -namespace UNF { | |
7 | - namespace Trie { | |
8 | - class NodeAllocator { | |
9 | - typedef unsigned NodeIndex; | |
10 | - typedef std::vector<unsigned char> UCharList; | |
11 | - typedef std::vector<bool> BitSet; | |
12 | - | |
13 | - private: | |
14 | - struct ForwardLink { | |
15 | - ForwardLink(NodeIndex i) : idx(i), next(NULL) {} | |
16 | - | |
17 | - NodeIndex append(NodeIndex beg_idx, unsigned num) { | |
18 | - ForwardLink* cur=this; | |
19 | - while(cur->next) cur=cur->next; | |
20 | - | |
21 | - for(NodeIndex i=beg_idx; i < beg_idx+num; i++) | |
22 | - cur = cur->next = new ForwardLink(i); | |
23 | - return beg_idx+num-1; | |
24 | - } | |
25 | - | |
26 | - void remove_next() { | |
27 | - ForwardLink* tmp=next; next=next->next; delete tmp; | |
28 | - } | |
29 | - | |
30 | - void delete_all_tail() { | |
31 | - for(ForwardLink* tmp=next; next; tmp=next) { | |
32 | - next=next->next; | |
33 | - delete tmp; | |
34 | - } | |
35 | - } | |
36 | - | |
37 | - NodeIndex idx; | |
38 | - ForwardLink* next; | |
39 | - }; | |
40 | - | |
41 | - public: | |
42 | - static const unsigned PER_LINK_SIZE=0x10000; | |
43 | - | |
44 | - public: | |
45 | - NodeAllocator(unsigned node_size) : root(0), used_base(node_size) { | |
46 | - last_idx = root.append(1,PER_LINK_SIZE); | |
47 | - } | |
48 | - ~NodeAllocator() { | |
49 | - root.delete_all_tail(); | |
50 | - } | |
51 | - | |
52 | - int allocate(unsigned char code) { | |
53 | - static UCharList codes(1); // XXX: thread unsafe | |
54 | - codes[0] = code; | |
55 | - return allocate(codes); | |
56 | - } | |
57 | - | |
58 | - int allocate(const UCharList& codes, ForwardLink* prev=NULL) { | |
59 | - if(!prev) prev=&root; | |
60 | - if(!prev->next) | |
61 | - last_idx = prev->append(last_idx+1, PER_LINK_SIZE); | |
62 | - | |
63 | - ForwardLink *cur = prev->next; | |
64 | - unsigned char min_cd = codes.front(); | |
65 | - | |
66 | - for(; cur->idx <= min_cd; prev=cur, cur=cur->next); | |
67 | - for(; cur->next; prev=cur,cur=cur->next) { | |
68 | - NodeIndex x = cur->idx - min_cd; | |
69 | - if(used_base[x]==false && can_allocate(cur, codes, x)) { | |
70 | - used_base[x] = true; | |
71 | - alloc(prev,codes,x); | |
72 | - return x; | |
73 | - } | |
74 | - } | |
75 | - return allocate(codes, cur); | |
76 | - } | |
77 | - | |
78 | - private: | |
79 | - bool can_allocate(ForwardLink* cur, const UCharList& codes, NodeIndex x) const { | |
80 | - cur=cur->next; | |
81 | - for(unsigned i=1;i < codes.size(); i++) { | |
82 | - for(; cur && cur->idx < x+codes[i]; cur=cur->next); | |
83 | - if(!cur || cur->idx > x+codes[i]) | |
84 | - return false; | |
85 | - } | |
86 | - return true; | |
87 | - } | |
88 | - | |
89 | - void alloc(ForwardLink* prev, const UCharList& codes, NodeIndex x) { | |
90 | - prev->remove_next(); | |
91 | - for(unsigned i=1; i < codes.size(); i++) { | |
92 | - for(; prev->next->idx < x+codes[i]; prev=prev->next); | |
93 | - prev->remove_next(); | |
94 | - } | |
95 | - } | |
96 | - | |
97 | - private: | |
98 | - ForwardLink root; | |
99 | - NodeIndex last_idx; | |
100 | - BitSet used_base; | |
101 | - }; | |
102 | - } | |
103 | -} | |
104 | - | |
105 | -#endif |
@@ -1,170 +0,0 @@ | ||
1 | -#ifndef UNF_TRIE_BUILDER_HH | |
2 | -#define UNF_TRIE_BUILDER_HH | |
3 | - | |
4 | -#include "node_allocator.hh" | |
5 | -#include "char_stream.hh" | |
6 | -#include "node.hh" | |
7 | -#include <fstream> | |
8 | -#include <cstring> | |
9 | -#include <string> | |
10 | -#include <iomanip> | |
11 | - | |
12 | -namespace UNF { | |
13 | - namespace Trie { | |
14 | - /** | |
15 | - * Trie key class | |
16 | - */ | |
17 | - struct Key { | |
18 | - Key(const std::string& key) : buf(key), cs(buf.c_str()) {} | |
19 | - | |
20 | - bool operator<(const Key& k) const { return strcmp(cs.cur(), k.cs.cur()) < 0; } | |
21 | - unsigned char read() { return cs.read(); } | |
22 | - unsigned char prev() const { return cs.prev(); } | |
23 | - unsigned char peek() const { return cs.peek(); } | |
24 | - void reset() { cs.setCur(buf.c_str()); } | |
25 | - virtual void set_node_value(Node& node) = 0; | |
26 | - | |
27 | - std::string buf; | |
28 | - CharStream cs; | |
29 | - }; | |
30 | - | |
31 | - struct AttrKey : public Key { | |
32 | - AttrKey(const std::string& key, unsigned attr) : Key(key), attr(attr) {} | |
33 | - virtual void set_node_value(Node& node) { node.set_value(attr); } | |
34 | - | |
35 | - unsigned attr; | |
36 | - }; | |
37 | - typedef std::vector<AttrKey> AttrKeyList; | |
38 | - | |
39 | - struct MappingKey : public Key { | |
40 | - static const unsigned OFFSET_BITLEN = 18; | |
41 | - static const unsigned OFFSET_BITMASK = 0x3FFFF; | |
42 | - | |
43 | - MappingKey(const std::string& key, const std::string& value, std::string& buffer) | |
44 | - : Key(key) { | |
45 | - value_info = (value.size()<<OFFSET_BITLEN) | buffer.size(); | |
46 | - buffer += value; | |
47 | - } | |
48 | - MappingKey(const std::string& key, const std::string& value, unsigned value_info) | |
49 | - : Key(key) { | |
50 | - this->value_info = (value.size()<<OFFSET_BITLEN) | (value_info&OFFSET_BITMASK); | |
51 | - } | |
52 | - | |
53 | - virtual void set_node_value(Node& node) { node.set_value(value_info); } | |
54 | - | |
55 | - unsigned value_info; | |
56 | - }; | |
57 | - typedef std::vector<MappingKey> MappingKeyList; | |
58 | - | |
59 | - /** | |
60 | - * Builder class | |
61 | - */ | |
62 | - template<class KeyList> | |
63 | - class Builder { | |
64 | - public: | |
65 | - Builder(KeyList& keys) | |
66 | - : keys(keys), node_size(count_node(keys)*1.5), alloc(node_size) { | |
67 | - nodes = new Node[node_size]; | |
68 | - } | |
69 | - ~Builder() { | |
70 | - delete [] nodes; | |
71 | - } | |
72 | - | |
73 | - Builder& build() { | |
74 | - build_impl(0, keys.size(), 0); | |
75 | - return *this; | |
76 | - } | |
77 | - | |
78 | - void output_nodes_cpp_array(std::ofstream& out, const char* prefix) { | |
79 | - if(node_size > 0xFF) | |
80 | - while(nodes[node_size-0xFF].is_unused()) | |
81 | - node_size--; | |
82 | - | |
83 | - out << "const unsigned " << prefix << "_NODES[]={" << std::endl; | |
84 | - for(unsigned i=0; i < node_size; i++) { | |
85 | - out << "0x" << std::hex << std::setw(8) << std::setfill('0') << std::right << std::hex << nodes[i].to_uint(); | |
86 | - if(i+1 < node_size) out << ','; | |
87 | - if((i+1)%10==0) out << std::endl; | |
88 | - } | |
89 | - out << "};" << std::endl << std::endl; | |
90 | - } | |
91 | - | |
92 | - private: | |
93 | - void build_impl(std::size_t beg, std::size_t end, int root_node) { | |
94 | - if(end-beg == 1) { | |
95 | - if(nodes[root_node].check_char()!='\0') { | |
96 | - for(; keys[beg].peek()!='\0'; keys[beg].read()) | |
97 | - root_node = set_node(root_node, alloc.allocate(keys[beg].peek()), keys[beg].peek()); | |
98 | - root_node = set_node(root_node, alloc.allocate('\0'), '\0'); | |
99 | - } | |
100 | - keys[beg].set_node_value(nodes[root_node]); | |
101 | - return; | |
102 | - } | |
103 | - | |
104 | - std::vector<unsigned char> children; | |
105 | - std::vector<std::size_t> ranges; | |
106 | - do { | |
107 | - children.push_back(keys[beg].peek()); | |
108 | - ranges.push_back(beg); | |
109 | - beg = end_of_same_node(keys, beg, end); | |
110 | - } while (beg != end); | |
111 | - ranges.push_back(end); | |
112 | - | |
113 | - int base_node = alloc.allocate(children); | |
114 | - for(std::size_t i=0; i < children.size(); i++) | |
115 | - build_impl(ranges[i], ranges[i+1], set_node(root_node, base_node, children[i])); | |
116 | - } | |
117 | - | |
118 | - int set_node(int node, int base_node, unsigned char child) { | |
119 | - int next = base_node + child; | |
120 | - nodes[node].set_base_index(base_node); | |
121 | - nodes[next].set_check_char(child); | |
122 | - return next; | |
123 | - } | |
124 | - | |
125 | - unsigned end_of_same_node(KeyList& keys, std::size_t beg, std::size_t end) { | |
126 | - unsigned char ch = keys[beg].read(); | |
127 | - std::size_t cur = beg+1; | |
128 | - for(; cur < end && ch == keys[cur].peek(); cur++) | |
129 | - keys[cur].read(); | |
130 | - return cur; | |
131 | - } | |
132 | - | |
133 | - unsigned count_node(KeyList& keys) { | |
134 | - unsigned count = count_node_impl(keys,0,keys.size()); | |
135 | - for(std::size_t i = 0; i < keys.size(); i++) | |
136 | - keys[i].reset(); | |
137 | - return count; | |
138 | - } | |
139 | - | |
140 | - unsigned count_node_impl(KeyList& keys, std::size_t beg, std::size_t end) { | |
141 | - if(end-beg == 1) { | |
142 | - unsigned count=1; | |
143 | - while(keys[beg].read()!='\0') | |
144 | - count++; | |
145 | - return count; | |
146 | - } | |
147 | - | |
148 | - std::vector<std::size_t> ranges; | |
149 | - do { | |
150 | - ranges.push_back(beg); | |
151 | - beg = end_of_same_node(keys, beg, end); | |
152 | - } while (beg != end); | |
153 | - ranges.push_back(end); | |
154 | - | |
155 | - unsigned count=ranges.size()-1; | |
156 | - for(std::size_t i=0; i < ranges.size()-1; i++) | |
157 | - count += count_node_impl(keys, ranges[i], ranges[i+1]); | |
158 | - return count; | |
159 | - } | |
160 | - | |
161 | - private: | |
162 | - KeyList& keys; | |
163 | - unsigned node_size; | |
164 | - Node* nodes; | |
165 | - NodeAllocator alloc; | |
166 | - }; | |
167 | - } | |
168 | -} | |
169 | - | |
170 | -#endif |
@@ -5,14 +5,6 @@ | ||
5 | 5 | namespace Trie { |
6 | 6 | class Node { |
7 | 7 | public: |
8 | - Node() : data(0xFFFFFFFF) {} | |
9 | - | |
10 | - void set_base_index(unsigned base_index) { data = (data&0xFF000000)+(base_index&0x00FFFFFF); } | |
11 | - void set_value(unsigned value) { set_base_index(value); } | |
12 | - void set_check_char(unsigned char ch) { data = (ch << 24) + base(); } | |
13 | - | |
14 | - bool is_unused() const { return data==0xFFFFFFFF; } | |
15 | - | |
16 | 8 | unsigned jump(unsigned char ch) const { return base() + ch; } |
17 | 9 | unsigned value() const { return base(); } |
18 | 10 | unsigned check_char() const { return data>>24; } |
@@ -24,9 +16,7 @@ | ||
24 | 16 | private: |
25 | 17 | unsigned base() const { return data & 0xFFFFFF; } |
26 | 18 | |
27 | - //XXX: private: | |
28 | - public: | |
29 | - // TODO: bit-fieldを使ってみる | |
19 | + private: | |
30 | 20 | unsigned data; |
31 | 21 | }; |
32 | 22 | } |
@@ -13,7 +13,6 @@ | ||
13 | 13 | : nodes(nodes), root(root), value(value) {} |
14 | 14 | |
15 | 15 | unsigned find_value(const char* key, int default_value) const { |
16 | - //std::cout << "# " << key << std::endl; | |
17 | 16 | unsigned node_index=root; |
18 | 17 | for(CharStream in(key);; in.read()) { |
19 | 18 | node_index = nodes[node_index].jump(in.peek()); |
@@ -20,7 +19,6 @@ | ||
20 | 19 | if(nodes[node_index].check_char()==in.peek()) { |
21 | 20 | unsigned terminal_index = nodes[node_index].jump('\0'); |
22 | 21 | if(nodes[terminal_index].check_char()=='\0') { |
23 | - //std::cout << " => " << nodes[terminal_index].value() << std::endl; | |
24 | 22 | return nodes[terminal_index].value(); |
25 | 23 | } |
26 | 24 | } else |
@@ -96,11 +94,6 @@ | ||
96 | 94 | }; |
97 | 95 | |
98 | 96 | class NormalizationForm : private Searcher { |
99 | - private: | |
100 | - // TODO: => word_append | |
101 | - static unsigned v_start(unsigned v) { return v&0x3FFFF; } | |
102 | - static unsigned v_end(unsigned v) { return v_start(v)+(v>>18); } | |
103 | - | |
104 | 97 | public: |
105 | 98 | NormalizationForm(const unsigned* node_uints, unsigned root, const char* value=NULL) |
106 | 99 | : Searcher(Node::from_uint_array(node_uints), root, value) {} |
@@ -116,8 +109,7 @@ | ||
116 | 109 | if(nodes[node_index].check_char()==in.prev()) { |
117 | 110 | unsigned terminal_index = nodes[node_index].jump('\0'); |
118 | 111 | if(nodes[terminal_index].check_char()=='\0') { |
119 | - unsigned v = nodes[terminal_index].value(); | |
120 | - buffer.append(value+v_start(v), value+v_end(v)); | |
112 | + word_append(buffer, value, nodes[terminal_index].value()); | |
121 | 113 | beg = in.cur(); |
122 | 114 | break; |
123 | 115 | } |
@@ -137,8 +129,7 @@ | ||
137 | 129 | |
138 | 130 | const char* const beg = in.cur(); |
139 | 131 | const char* current_char_head = in.cur(); |
140 | - const char* composed_char = NULL; | |
141 | - const char* composed_char_end = NULL; | |
132 | + unsigned composed_char_info = 0; | |
142 | 133 | |
143 | 134 | unsigned node_index = root; |
144 | 135 | unsigned retry_root_node = root; |
@@ -161,9 +152,7 @@ | ||
161 | 152 | node_index = next_index; |
162 | 153 | unsigned terminal_index = nodes[node_index].jump('\0'); |
163 | 154 | if(nodes[terminal_index].check_char()=='\0') { |
164 | - unsigned v = nodes[terminal_index].value(); | |
165 | - composed_char = value+v_start(v); | |
166 | - composed_char_end = value+v_end(v); | |
155 | + composed_char_info = nodes[terminal_index].value(); | |
167 | 156 | |
168 | 157 | in.mark_as_last_valid_point(); |
169 | 158 | if(in.eos() || retry_root_class > in.get_canonical_class()) |
@@ -182,9 +171,9 @@ | ||
182 | 171 | } |
183 | 172 | } |
184 | 173 | |
185 | - if(composed_char) { | |
174 | + if(composed_char_info != 0) { | |
186 | 175 | // append composed unicode-character and skipped combining-characters |
187 | - buf.append(composed_char, composed_char_end); | |
176 | + word_append(buf, value, composed_char_info); | |
188 | 177 | in.append_skipped_chars_to_str(buf); |
189 | 178 | in.reset_at_marked_point(); |
190 | 179 | } else { |
@@ -193,6 +182,11 @@ | ||
193 | 182 | in.append_read_char_to_str(buf, beg); |
194 | 183 | } |
195 | 184 | } |
185 | + | |
186 | + private: | |
187 | + static void word_append(std::string& buffer, const char* base, unsigned pos_info) { | |
188 | + buffer.append(base+(pos_info&0x3FFFF), pos_info>>18); | |
189 | + } | |
196 | 190 | }; |
197 | 191 | } |
198 | 192 | } |
@@ -1,9 +1,8 @@ | ||
1 | 1 | CXX=g++ |
2 | 2 | CXX_FLAGS=-O2 -Wall -ansi -pedantic-errors |
3 | 3 | |
4 | -COMMANDS=bin/unf bin/unf-test bin/unf-time bin/gen-unf-table | |
4 | +COMMANDS=bin/unf bin/unf-test bin/unf-time | |
5 | 5 | SRC=src/unf |
6 | -BUILD_TRIES=${SRC}/trie/builder.hh ${SRC}/trie/char_stream.hh ${SRC}/trie/node_allocator.hh ${SRC}/trie/node.hh | |
7 | 6 | SEARCH_TRIES=${SRC}/trie/char_stream.hh ${SRC}/trie/node.hh ${SRC}/trie/searcher.hh |
8 | 7 | |
9 | 8 | all: bin ${COMMANDS} |
@@ -11,9 +10,6 @@ | ||
11 | 10 | bin: |
12 | 11 | mkdir bin |
13 | 12 | |
14 | -bin/gen-unf-table: ${SRC}/gen-unf-table.cc ${BUILD_TRIES} | |
15 | - ${CXX} ${CXX_FLAGS} -o ${@} ${<} | |
16 | - | |
17 | 13 | bin/unf: ${SRC}/unf.cc ${SRC}/normalizer.hh ${SRC}/table.hh ${SRC}/util.hh ${SEARCH_TRIES} |
18 | 14 | ${CXX} ${CXX_FLAGS} -o ${@} ${<} |
19 | 15 |
@@ -28,6 +24,3 @@ | ||
28 | 24 | |
29 | 25 | test: bin/unf-test |
30 | 26 | ${<} < data/normalization-test.txt |
31 | - | |
32 | -gen-table: bin/gen-unf-table | |
33 | - bin/gen-unf-table ${SRC}/table.hh data |